From 08f78763f4b2c11d7df609f5842ca96e4fa02dae Mon Sep 17 00:00:00 2001 From: Oliver Date: Tue, 3 Nov 2026 18:23:17 +1100 Subject: [PATCH] Additional coverage (#908) * Add coverage for settings widgets * Additional unit tests --- lib/api.dart | 3 + test/setup.dart | 29 +- test/widget/detail_test.dart | 368 +++++++++++++++ test/widget/harness.dart | 280 ++++++++++++ test/widget/navigation_test.dart | 119 +++++ test/widget/settings_test.dart | 762 +++++++++++++++++++++++++++++++ 6 files changed, 1560 insertions(+), 1 deletion(-) create mode 100644 test/widget/detail_test.dart create mode 100644 test/widget/harness.dart create mode 100644 test/widget/navigation_test.dart create mode 100644 test/widget/settings_test.dart diff --git a/lib/api.dart b/lib/api.dart index 394aa26c..13acf7c9 100644 --- a/lib/api.dart +++ b/lib/api.dart @@ -833,6 +833,9 @@ class InvenTreeAPI { _loginRequired = false; profile = null; + _notification_timer?.cancel(); + _notification_timer = null; + // Drop the in-memory session (it remains in secure storage) session.onChanged = null; session = SessionStore(); diff --git a/test/setup.dart b/test/setup.dart index 370b96c7..0c065467 100644 --- a/test/setup.dart +++ b/test/setup.dart @@ -1,3 +1,5 @@ +import "dart:io"; + import "package:flutter/services.dart"; import "package:flutter_test/flutter_test.dart"; import "package:package_info_plus/package_info_plus.dart"; @@ -17,6 +19,20 @@ class CustomBinding extends AutomatedTestWidgetsFlutterBinding { // to test handling of storage errors final Set secureStorageFailures = {}; +// Directory for temporary and cache files (see setupTestEnv) +late String testTempDirectory; + +/* + * Use a new (empty) directory for temporary and cache files. + * Note: The image cache does not reliably save its index within a widget test, + * so tests which display images should use a new directory each time. + */ +void useNewTempDirectory() { + testTempDirectory = Directory.systemTemp + .createTempSync("inventree_test_") + .path; +} + void setupTestEnv() { // Uses custom binding to not override the http client CustomBinding(); @@ -31,12 +47,23 @@ void setupTestEnv() { ); // Mock the path provider + // Documents (e.g. the preferences database) are stored in the working directory, + // while temporary and cache files (e.g. downloaded images) go to a temporary directory + useNewTempDirectory(); + const MethodChannel channel = MethodChannel( "plugins.flutter.io/path_provider", ); TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger .setMockMethodCallHandler(channel, (MethodCall methodCall) async { - return "."; + switch (methodCall.method) { + case "getTemporaryDirectory": + case "getApplicationSupportDirectory": + case "getApplicationCacheDirectory": + return testTempDirectory; + default: + return "."; + } }); // Mock secure storage (used for storing profile session cookies) with a diff --git a/test/widget/detail_test.dart b/test/widget/detail_test.dart new file mode 100644 index 00000000..85540c6a --- /dev/null +++ b/test/widget/detail_test.dart @@ -0,0 +1,368 @@ +/* + * Widget tests for the "detail" screens, using the demo dataset. + * + * These tests require a running InvenTree server (see setup.dart) + * with the demo dataset loaded. They do not modify any data. + * + * Each test finds a suitable object on the server, displays its detail + * screen, waits for it to load, and then visits each tab. + * On each tab, every link to another screen is opened (and closed again). + * Any exception thrown while building the screens causes the test to fail. + */ + +import "package:flutter/material.dart"; +import "package:flutter_test/flutter_test.dart"; +import "package:one_context/one_context.dart"; + +import "package:inventree/inventree/build.dart"; +import "package:inventree/inventree/company.dart"; +import "package:inventree/inventree/model.dart"; +import "package:inventree/inventree/part.dart"; +import "package:inventree/inventree/purchase_order.dart"; +import "package:inventree/inventree/sales_order.dart"; +import "package:inventree/inventree/stock.dart"; +import "package:inventree/inventree/transfer_order.dart"; +import "package:inventree/widget/build/build_detail.dart"; +import "package:inventree/widget/build/build_item_detail.dart"; +import "package:inventree/widget/build/build_line_detail.dart"; +import "package:inventree/widget/company/company_detail.dart"; +import "package:inventree/widget/company/manufacturer_part_detail.dart"; +import "package:inventree/widget/company/supplier_part_detail.dart"; +import "package:inventree/widget/order/extra_line_detail.dart"; +import "package:inventree/widget/order/po_line_detail.dart"; +import "package:inventree/widget/order/purchase_order_detail.dart"; +import "package:inventree/widget/order/sales_order_detail.dart"; +import "package:inventree/widget/order/so_line_detail.dart"; +import "package:inventree/widget/order/so_shipment_detail.dart"; +import "package:inventree/widget/order/transfer_order_detail.dart"; +import "package:inventree/widget/order/transfer_order_line_detail.dart"; +import "package:inventree/widget/part/category_display.dart"; +import "package:inventree/widget/part/part_detail.dart"; +import "package:inventree/widget/refreshable_state.dart"; +import "package:inventree/widget/stock/location_display.dart"; +import "package:inventree/widget/stock/stock_detail.dart"; + +import "../setup.dart"; +import "harness.dart"; + +/* + * Find the first object matching [filters], and load its full details + */ +Future fetchFirst( + WidgetTester tester, + T model, { + Map filters = const {}, +}) async { + final results = await settle( + tester, + model.list(filters: {...filters, "limit": "1"}), + ); + + expect( + results, + isNotEmpty, + reason: "No ${T} matching ${filters} in the demo dataset", + ); + + final InvenTreeModel? instance = await settle( + tester, + model.get(results.first.pk), + ); + + expect(instance, isA()); + + return instance! as T; +} + +/* + * Display a detail [screen], and wait for it to load. + * Then display each tab, and return to the first tab. + */ +Future checkDetailScreen(WidgetTester tester, Widget screen) async { + await pumpScreen(tester, screen); + + final state = + tester.state(find.byWidget(screen)) as RefreshableState; + + await waitUntil(tester, () => state.loaded, reason: "${screen} loaded"); + await idle(tester); + + expect(find.byType(AppBar), findsWidgets); + + final Finder tabs = find.descendant( + of: find.byType(TabBar), + matching: find.byType(Tab), + ); + + final int tabCount = tabs.evaluate().length; + + await followLinks(tester, screen); + + for (int idx = 1; idx < tabCount; idx++) { + await tester.tap(tabs.at(idx)); + await idle(tester); + await followLinks(tester, screen); + } + + if (tabCount > 0) { + await tester.tap(tabs.first); + await idle(tester); + } + + // Refresh the screen (as per a "pull down" gesture) + state.refresh(state.context); + + await waitUntil(tester, () => state.loaded, reason: "${screen} reloaded"); + await idle(tester); +} + +void main() { + setupTestEnv(); + mockSharedPreferences(); + + setUp(() { + OneContext().key = GlobalKey(); + useNewTempDirectory(); + }); + + group("Part Detail:", () { + final Map> parts = { + "Assembly": {"assembly": "true", "has_stock": "true"}, + "Component": {"component": "true", "purchaseable": "true"}, + "Template": {"is_template": "true"}, + "Trackable": {"trackable": "true"}, + "Salable": {"salable": "true"}, + }; + + parts.forEach((name, filters) { + testWidgets(name, (tester) async { + await withServer(tester, displayAll: true, () async { + final part = await fetchFirst( + tester, + InvenTreePart(), + filters: filters, + ); + + await checkDetailScreen(tester, PartDetailWidget(part)); + }); + }); + }); + }); + + group("Part Category:", () { + testWidgets("Top Level", (tester) async { + await withServer(tester, displayAll: true, () async { + await checkDetailScreen(tester, CategoryDisplayWidget(null)); + }); + }); + + testWidgets("Category", (tester) async { + await withServer(tester, displayAll: true, () async { + final category = await fetchFirst( + tester, + InvenTreePartCategory(), + filters: {"parent": "1"}, + ); + + await checkDetailScreen(tester, CategoryDisplayWidget(category)); + }); + }); + }); + + group("Stock Detail:", () { + final Map> items = { + "Serialized": {"serialized": "true"}, + "Batch": {"serialized": "false", "has_batch": "true"}, + "Testable": { + "part_detail": "true", + "serialized": "true", + "has_tests": "true", + }, + }; + + items.forEach((name, filters) { + testWidgets(name, (tester) async { + await withServer(tester, displayAll: true, () async { + final item = await fetchFirst( + tester, + InvenTreeStockItem(), + filters: filters, + ); + + await checkDetailScreen(tester, StockDetailWidget(item)); + }); + }); + }); + }); + + group("Stock Location:", () { + testWidgets("Top Level", (tester) async { + await withServer(tester, displayAll: true, () async { + await checkDetailScreen(tester, LocationDisplayWidget(null)); + }); + }); + + testWidgets("Location", (tester) async { + await withServer(tester, displayAll: true, () async { + final location = await fetchFirst( + tester, + InvenTreeStockLocation(), + filters: {"parent": "1"}, + ); + + await checkDetailScreen(tester, LocationDisplayWidget(location)); + }); + }); + }); + + /* + * Test the detail screen for the first [model] matching [filters] + */ + void detailTest( + String name, + T model, + Widget Function(T instance) screen, { + Map filters = const {}, + }) { + testWidgets(name, (tester) async { + await withServer(tester, displayAll: true, () async { + final T instance = await fetchFirst(tester, model, filters: filters); + + await checkDetailScreen(tester, screen(instance)); + }); + }); + } + + group("Purchase Order:", () { + detailTest( + "Open", + InvenTreePurchaseOrder(), + (order) => PurchaseOrderDetailWidget(order), + filters: {"outstanding": "true"}, + ); + + detailTest( + "Closed", + InvenTreePurchaseOrder(), + (order) => PurchaseOrderDetailWidget(order), + filters: {"outstanding": "false"}, + ); + + detailTest( + "Line Item", + InvenTreePOLineItem(), + (line) => POLineDetailWidget(line), + ); + + detailTest( + "Extra Line Item", + InvenTreePOExtraLineItem(), + (line) => ExtraLineDetailWidget(line), + ); + }); + + group("Sales Order:", () { + detailTest( + "Open", + InvenTreeSalesOrder(), + (order) => SalesOrderDetailWidget(order), + filters: {"outstanding": "true"}, + ); + + detailTest( + "Closed", + InvenTreeSalesOrder(), + (order) => SalesOrderDetailWidget(order), + filters: {"outstanding": "false"}, + ); + + detailTest( + "Line Item", + InvenTreeSOLineItem(), + (line) => SoLineDetailWidget(line), + ); + + detailTest( + "Extra Line Item", + InvenTreeSOExtraLineItem(), + (line) => ExtraLineDetailWidget(line), + ); + + detailTest( + "Shipment", + InvenTreeSalesOrderShipment(), + (shipment) => SOShipmentDetailWidget(shipment), + ); + }); + + group("Transfer Order:", () { + detailTest( + "Order", + InvenTreeTransferOrder(), + (order) => TransferOrderDetailWidget(order), + ); + + detailTest( + "Line Item", + InvenTreeTransferOrderLineItem(), + (line) => TransferOrderLineDetailWidget(line), + ); + }); + + group("Build Order:", () { + detailTest( + "Open", + InvenTreeBuildOrder(), + (build) => BuildOrderDetailWidget(build), + filters: {"outstanding": "true"}, + ); + + detailTest( + "Closed", + InvenTreeBuildOrder(), + (build) => BuildOrderDetailWidget(build), + filters: {"outstanding": "false"}, + ); + + detailTest( + "Line Item", + InvenTreeBuildLine(), + (line) => BuildLineDetailWidget(line), + ); + + detailTest( + "Allocated Item", + InvenTreeBuildItem(), + (item) => BuildItemDetailWidget(item), + ); + }); + + group("Company:", () { + final Map> companies = { + "Supplier": {"is_supplier": "true"}, + "Manufacturer": {"is_manufacturer": "true"}, + "Customer": {"is_customer": "true"}, + }; + + companies.forEach((name, filters) { + detailTest( + name, + InvenTreeCompany(), + (company) => CompanyDetailWidget(company), + filters: filters, + ); + }); + + detailTest( + "Supplier Part", + InvenTreeSupplierPart(), + (part) => SupplierPartDetailWidget(part), + ); + + detailTest( + "Manufacturer Part", + InvenTreeManufacturerPart(), + (part) => ManufacturerPartDetailWidget(part), + ); + }); +} diff --git a/test/widget/harness.dart b/test/widget/harness.dart new file mode 100644 index 00000000..6c010a22 --- /dev/null +++ b/test/widget/harness.dart @@ -0,0 +1,280 @@ +/* + * Shared helpers for widget tests. + * + * Widget tests run in a "fake async" zone, where time only advances when the + * test pumps the widget tree. File and network access (the preferences + * database, the InvenTree server) needs real time to progress as well, + * so these helpers alternate between the two (see step() and settle()). + */ + +import "package:adaptive_theme/adaptive_theme.dart"; +import "package:flutter/material.dart"; +import "package:flutter/services.dart"; +import "package:flutter_localizations/flutter_localizations.dart"; +import "package:flutter_localized_locales/flutter_localized_locales.dart"; +import "package:flutter_tabler_icons/flutter_tabler_icons.dart"; +import "package:flutter_test/flutter_test.dart"; +import "package:one_context/one_context.dart"; + +import "package:inventree/api.dart"; +import "package:inventree/l10n/collected/app_localizations.dart"; +import "package:inventree/l10n/supported_locales.dart"; +import "package:inventree/preferences.dart"; +import "package:inventree/widget/refreshable_state.dart"; + +import "../setup.dart"; + +// In-memory shared preferences (used by AdaptiveTheme to store the theme mode) +final Map sharedPreferences = {}; + +void mockSharedPreferences() { + const MethodChannel channel = MethodChannel( + "plugins.flutter.io/shared_preferences", + ); + + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger + .setMockMethodCallHandler(channel, (MethodCall call) async { + final Map args = + (call.arguments as Map?) ?? {}; + + switch (call.method) { + case "getAll": + return sharedPreferences; + case "remove": + sharedPreferences.remove(args["key"]); + return true; + case "clear": + sharedPreferences.clear(); + return true; + default: + // setBool, setString, setInt, etc + if (call.method.startsWith("set")) { + sharedPreferences[args["key"] as String] = + args["value"] as Object; + return true; + } + + return null; + } + }); +} + +/* + * Show [screen] within an app which matches the real app setup + */ +Future pumpScreen(WidgetTester tester, Widget screen) async { + // Tall enough to show every setting without scrolling + tester.view.physicalSize = const Size(800, 2400); + tester.view.devicePixelRatio = 1.0; + addTearDown(tester.view.reset); + + await tester.pumpWidget( + AdaptiveTheme( + light: ThemeData.light(), + dark: ThemeData.dark(), + initial: AdaptiveThemeMode.light, + builder: (light, dark) => MaterialApp( + theme: light, + darkTheme: dark, + builder: OneContext().builder, + navigatorKey: OneContext().key, + localizationsDelegates: [ + I18N.delegate, + LocaleNamesLocalizationsDelegate(), + GlobalMaterialLocalizations.delegate, + GlobalCupertinoLocalizations.delegate, + GlobalWidgetsLocalizations.delegate, + ], + supportedLocales: supported_locales, + home: screen, + ), + ), + ); + + // Localizations are loaded asynchronously, before the screen is built + await waitUntil(tester, () => find.byWidget(screen).evaluate().isNotEmpty); +} + +/* + * Allow both real async operations (e.g. file and network access) + * and fake time (e.g. timers, animations) to progress, + * then rebuild the widget tree. + * + * Note: Database operations must be started in the test (fake async) zone, + * as the preferences database uses short timers between operations. + * Waiting on them inside tester.runAsync() would block forever. + */ +Future step(WidgetTester tester) async { + await tester.runAsync( + () => Future.delayed(const Duration(milliseconds: 5)), + ); + await tester.pump(const Duration(milliseconds: 10)); +} + +// Wait until [done] returns true +Future waitUntil( + WidgetTester tester, + bool Function() done, { + String? reason, +}) async { + final Stopwatch timer = Stopwatch()..start(); + + while (!done() && timer.elapsed < const Duration(seconds: 10)) { + await step(tester); + } + + expect(done(), isTrue, reason: reason); +} + +// Wait for [future] (started in the test zone) to complete +Future settle(WidgetTester tester, Future future) async { + bool complete = false; + T? value; + Object? error; + + future.then( + (T result) { + value = result; + complete = true; + }, + onError: (Object e) { + error = e; + complete = true; + }, + ); + + await waitUntil(tester, () => complete); + + if (error != null) { + throw error!; + } + + return value as T; +} + +/* + * Connect to the test server (see setup.dart) from within a widget test. + * + * Call disconnectInWidgetTest() at the end of the test, + * to stop the timers started by the connection. + */ +Future connectInWidgetTest(WidgetTester tester) async { + await settle(tester, connectToTestServer()); + + expect(InvenTreeAPI().isConnected(), isTrue); +} + +Future disconnectInWidgetTest(WidgetTester tester) async { + InvenTreeAPI().disconnectFromServer(); + + // Allow any idle HTTP connections to expire + await tester.pump(const Duration(seconds: 16)); +} + +// Return true if every displayed screen has finished loading +bool allLoaded(WidgetTester tester) => tester + .stateList(find.byWidgetPredicate((w) => w is StatefulWidget)) + .whereType>() + .every((state) => state.loaded); + +// Wait for screens to load, and any other outstanding requests to complete +Future idle(WidgetTester tester) async { + await waitUntil(tester, () => allLoaded(tester), reason: "screens loaded"); + + for (int i = 0; i < 20; i++) { + await step(tester); + } + + // Complete any page transitions + await tester.pump(const Duration(milliseconds: 500)); +} + +/* + * Open each (visible) link to another screen, then return to [screen]. + * + * By default, links are the "chevron" icons displayed by LinkIcon(). + * [beforeEach] is called before each link is found (e.g. to open a menu). + */ +Future followLinks( + WidgetTester tester, + Widget screen, { + Finder Function()? links, + Future Function()? beforeEach, +}) async { + links ??= () => find.byIcon(TablerIcons.chevron_right).hitTestable(); + + bool isCurrent() => + ModalRoute.of( + tester.element(find.byWidget(screen, skipOffstage: false)), + )?.isCurrent ?? + false; + + await beforeEach?.call(); + + final int count = links().evaluate().length; + + for (int idx = 0; idx < count; idx++) { + if (idx > 0) { + await beforeEach?.call(); + } + + // The screen may have changed (e.g. reloaded) + if (idx >= links().evaluate().length) { + break; + } + + await tester.tap(links().at(idx)); + await idle(tester); + + // Return to the original screen + while (!isCurrent()) { + OneContext().key.currentState!.pop(); + await idle(tester); + } + } +} + +// Optional information, which is hidden by default +const Map displaySettings = { + INV_SHOW_PK: true, + INV_SHOW_HISTORY: true, +}; + +/* + * Connect to the test server, run [body], then disconnect. + * + * If [displayAll] is set, optional information is displayed (more code paths) + */ +Future withServer( + WidgetTester tester, + Future Function() body, { + bool displayAll = false, +}) async { + await connectInWidgetTest(tester); + + if (displayAll) { + await settle( + tester, + Future.wait([ + for (final entry in displaySettings.entries) + InvenTreeSettingsManager().setValue(entry.key, entry.value), + ]), + ); + } + + try { + await body(); + } finally { + if (displayAll) { + await settle( + tester, + Future.wait([ + for (final key in displaySettings.keys) + InvenTreeSettingsManager().removeValue(key), + ]), + ); + } + + await disconnectInWidgetTest(tester); + } +} diff --git a/test/widget/navigation_test.dart b/test/widget/navigation_test.dart new file mode 100644 index 00000000..ddf74998 --- /dev/null +++ b/test/widget/navigation_test.dart @@ -0,0 +1,119 @@ +/* + * Widget tests for navigating the app (home screen, menu and search), + * using the demo dataset. + * + * These tests require a running InvenTree server (see setup.dart) + * with the demo dataset loaded. They do not modify any data. + * + * Each screen which is opened is allowed to load, and then closed again. + * Any exception thrown while building the screens causes the test to fail. + */ + +import "package:flutter/material.dart"; +import "package:flutter_test/flutter_test.dart"; +import "package:one_context/one_context.dart"; + +import "package:inventree/api.dart"; +import "package:inventree/widget/home.dart"; +import "package:inventree/widget/part/category_display.dart"; +import "package:inventree/widget/search.dart"; + +import "../setup.dart"; +import "harness.dart"; + +void main() { + setupTestEnv(); + mockSharedPreferences(); + + setUp(() { + OneContext().key = GlobalKey(); + useNewTempDirectory(); + }); + + testWidgets("Home Screen", (tester) async { + await withServer(tester, () async { + const Widget home = InvenTreeHomePage(); + + await pumpScreen(tester, home); + + // The home screen connects to the selected server + await waitUntil( + tester, + () => + InvenTreeAPI().isConnected() && + find.byType(Card).evaluate().isNotEmpty, + reason: "home screen connected", + ); + + await idle(tester); + + // Open each of the home screen tiles + await followLinks( + tester, + home, + links: () => find + .descendant(of: find.byType(Card), matching: find.byType(ListTile)) + .hitTestable(), + ); + }); + }); + + testWidgets("Menu", (tester) async { + await withServer(tester, () async { + final Widget screen = CategoryDisplayWidget(null); + + await pumpScreen(tester, screen); + await idle(tester); + + Finder drawerItems() => find + .descendant(of: find.byType(Drawer), matching: find.byType(ListTile)) + .hitTestable(); + + // Open each of the menu items + await followLinks( + tester, + screen, + links: drawerItems, + beforeEach: () async { + if (drawerItems().evaluate().isEmpty) { + await tester.tap(find.byIcon(Icons.menu)); + await idle(tester); + } + + expect(drawerItems(), findsWidgets); + }, + ); + }); + }); + + testWidgets("Search", (tester) async { + await withServer(tester, () async { + const Widget screen = SearchWidget(true); + + await pumpScreen(tester, screen); + await idle(tester); + + // Search result tiles (one for each model type) + Finder results() => find + .byWidgetPredicate((w) => w is ListTile && w.onTap != null) + .hitTestable(); + + await tester.enterText(find.byType(TextField), "chair"); + + await waitUntil( + tester, + () => results().evaluate().length > 1, + reason: "search results displayed", + ); + + await idle(tester); + + // Open each set of search results + await followLinks(tester, screen, links: results); + + // Clear the search + await tester.enterText(find.byType(TextField), ""); + await idle(tester); + }); + }); +} diff --git a/test/widget/settings_test.dart b/test/widget/settings_test.dart new file mode 100644 index 00000000..956fae8b --- /dev/null +++ b/test/widget/settings_test.dart @@ -0,0 +1,762 @@ +/* + * Widget tests for the settings screens. + * + * Settings and profiles are stored in the on-disk preferences database, + * so database operations are waited on with settle() (see harness.dart) + */ + +import "package:flutter/material.dart"; +import "package:flutter_tabler_icons/flutter_tabler_icons.dart"; +import "package:flutter_test/flutter_test.dart"; +import "package:one_context/one_context.dart"; +import "package:package_info_plus/package_info_plus.dart"; + +import "package:inventree/l10.dart"; +import "package:inventree/preferences.dart"; +import "package:inventree/settings/about.dart"; +import "package:inventree/settings/app_settings.dart"; +import "package:inventree/settings/barcode_settings.dart"; +import "package:inventree/settings/home_settings.dart"; +import "package:inventree/settings/login.dart"; +import "package:inventree/settings/part_settings.dart"; +import "package:inventree/settings/purchase_order_settings.dart"; +import "package:inventree/settings/sales_order_settings.dart"; +import "package:inventree/settings/select_server.dart"; +import "package:inventree/settings/settings.dart"; +import "package:inventree/settings/stock_settings.dart"; +import "package:inventree/user_profile.dart"; + +import "../fake_server.dart"; +import "../setup.dart"; +import "harness.dart"; + +const String profileName = "Settings Widget Test"; + +UserProfileDBManager get manager => UserProfileDBManager(); + +InvenTreeSettingsManager get settings => InvenTreeSettingsManager(); + +// Wait until the stored value for [key] matches [expected] +Future waitForSetting( + WidgetTester tester, + String key, + dynamic expected, +) async { + dynamic value; + + for (int i = 0; i < 50; i++) { + value = await settle(tester, settings.getValue(key, null)); + + if (value == expected) { + break; + } + } + + expect(value, equals(expected), reason: "setting '${key}'"); +} + +Future setSettings(WidgetTester tester, Map values) { + return settle( + tester, + Future.wait([ + for (final entry in values.entries) + settings.setValue(entry.key, entry.value), + ]), + ); +} + +Future removeSettings(WidgetTester tester, Iterable keys) { + return settle( + tester, + Future.wait([for (final key in keys) settings.removeValue(key)]), + ); +} + +// Find the ListTile with the given title +Finder tile(String title) => find.widgetWithText(ListTile, title); + +Finder switchFinder(String title) => + find.descendant(of: tile(title), matching: find.byType(Switch)); + +bool switchValue(WidgetTester tester, String title) => + tester.widget(switchFinder(title)).value; + +/* + * A boolean setting, displayed as a switch with the given title + */ +class SwitchSetting { + const SwitchSetting(this.title, this.key, this.defaultValue); + + final String title; + final String key; + final bool defaultValue; +} + +/* + * Check that each switch setting on [screen]: + * - Displays the stored value + * - Updates the stored value when toggled + */ +Future checkSwitchSettings( + WidgetTester tester, + Widget screen, + List switches, +) async { + // Store the non-default value, to check it is loaded + await setSettings(tester, {for (final s in switches) s.key: !s.defaultValue}); + + await pumpScreen(tester, screen); + + await waitUntil( + tester, + () => switches.every( + (s) => + switchFinder(s.title).evaluate().isNotEmpty && + switchValue(tester, s.title) != s.defaultValue, + ), + reason: "stored values are displayed", + ); + + for (final s in switches) { + await tester.tap(switchFinder(s.title)); + await tester.pump(); + + expect(switchValue(tester, s.title), equals(s.defaultValue)); + + await waitForSetting(tester, s.key, s.defaultValue); + } + + await removeSettings(tester, switches.map((s) => s.key)); +} + +void main() { + setupTestEnv(); + mockSharedPreferences(); + + setUp(() { + // A new navigator for each test, so no state carries over + OneContext().key = GlobalKey(); + }); + + group("Switch Settings:", () { + testWidgets("App Settings", (tester) async { + await checkSwitchSettings(tester, InvenTreeAppSettingsWidget(), [ + SwitchSetting(L10().showPkValue, INV_SHOW_PK, false), + SwitchSetting(L10().history, INV_SHOW_HISTORY, false), + SwitchSetting(L10().labelPrinting, INV_ENABLE_LABEL_PRINTING, true), + SwitchSetting(L10().strictHttps, INV_STRICT_HTTPS, false), + SwitchSetting(L10().errorReportUpload, INV_REPORT_ERRORS, true), + SwitchSetting(L10().serverError, INV_SOUNDS_SERVER, true), + SwitchSetting(L10().barcodeTones, INV_SOUNDS_BARCODE, true), + ]); + + // Dark mode reflects (and changes) the current theme + expect(switchValue(tester, L10().darkMode), isFalse); + + await tester.tap(switchFinder(L10().darkMode)); + await tester.pumpAndSettle(); + + expect(switchValue(tester, L10().darkMode), isTrue); + expect( + Theme.of(tester.element(switchFinder(L10().darkMode))).brightness, + equals(Brightness.dark), + ); + + await tester.tap(switchFinder(L10().darkMode)); + await tester.pumpAndSettle(); + + expect(switchValue(tester, L10().darkMode), isFalse); + }); + + testWidgets("Home Screen Settings", (tester) async { + await checkSwitchSettings(tester, HomeScreenSettingsWidget(), [ + SwitchSetting(L10().homeShowSubscribed, INV_HOME_SHOW_SUBSCRIBED, true), + SwitchSetting(L10().homeShowPo, INV_HOME_SHOW_PO, true), + SwitchSetting(L10().homeShowSo, INV_HOME_SHOW_SO, true), + SwitchSetting(L10().homeShowShipments, INV_HOME_SHOW_SHIPMENTS, true), + SwitchSetting(L10().homeShowSuppliers, INV_HOME_SHOW_SUPPLIERS, true), + SwitchSetting(L10().homeShowTransfer, INV_HOME_SHOW_TRANSFER, true), + SwitchSetting(L10().homeShowCustomers, INV_HOME_SHOW_CUSTOMERS, true), + ]); + }); + + testWidgets("Barcode Settings", (tester) async { + await checkSwitchSettings(tester, InvenTreeBarcodeSettingsWidget(), [ + SwitchSetting(L10().barcodeScanSingle, INV_BARCODE_SCAN_SINGLE, false), + ]); + }); + + testWidgets("Part Settings", (tester) async { + await checkSwitchSettings(tester, InvenTreePartSettingsWidget(), [ + SwitchSetting(L10().bom, INV_PART_SHOW_BOM, true), + SwitchSetting(L10().partPricing, INV_PART_SHOW_PRICING, true), + SwitchSetting( + L10().partRequirements, + INV_PART_SHOW_REQUIREMENTS, + false, + ), + ]); + }); + + testWidgets("Stock Settings", (tester) async { + await checkSwitchSettings(tester, InvenTreeStockSettingsWidget(), [ + SwitchSetting(L10().testResults, INV_STOCK_SHOW_TESTS, true), + SwitchSetting(L10().confirmScan, INV_STOCK_CONFIRM_SCAN, false), + ]); + }); + + testWidgets("Purchase Order Settings", (tester) async { + await checkSwitchSettings( + tester, + InvenTreePurchaseOrderSettingsWidget(), + [ + SwitchSetting(L10().purchaseOrderEnable, INV_PO_ENABLE, true), + SwitchSetting( + L10().purchaseOrderShowCamera, + INV_PO_SHOW_CAMERA, + true, + ), + SwitchSetting( + L10().purchaseOrderConfirmScan, + INV_PO_CONFIRM_SCAN, + true, + ), + ], + ); + }); + + testWidgets("Sales Order Settings", (tester) async { + await checkSwitchSettings(tester, InvenTreeSalesOrderSettingsWidget(), [ + SwitchSetting(L10().salesOrderEnable, INV_SO_ENABLE, true), + SwitchSetting(L10().salesOrderShowCamera, INV_SO_SHOW_CAMERA, true), + ]); + }); + }); + + group("App Settings:", () { + final Map orientationIcons = { + SCREEN_ORIENTATION_SYSTEM: Icons.screen_rotation, + SCREEN_ORIENTATION_PORTRAIT: Icons.screen_lock_portrait, + SCREEN_ORIENTATION_LANDSCAPE: Icons.screen_lock_landscape, + }; + + orientationIcons.forEach((orientation, icon) { + testWidgets("Orientation ${orientation}", (tester) async { + await setSettings(tester, {INV_SCREEN_ORIENTATION: orientation}); + + await pumpScreen(tester, InvenTreeAppSettingsWidget()); + + await waitUntil( + tester, + () => find + .descendant( + of: tile(L10().orientation), + matching: find.byIcon(icon), + ) + .evaluate() + .isNotEmpty, + ); + + await removeSettings(tester, [INV_SCREEN_ORIENTATION]); + }); + }); + + testWidgets("Language", (tester) async { + await pumpScreen(tester, InvenTreeAppSettingsWidget()); + + await waitUntil( + tester, + () => find + .descendant( + of: tile(L10().language), + matching: find.text(L10().languageDefault), + ) + .evaluate() + .isNotEmpty, + reason: "default language is displayed", + ); + + await settle( + tester, + settings.setSelectedLocale(const Locale("de", "DE")), + ); + + // Remove the existing screen, so that the settings are reloaded + await tester.pumpWidget(const SizedBox()); + + await pumpScreen(tester, InvenTreeAppSettingsWidget()); + + await waitUntil( + tester, + () => find + .descendant( + of: tile(L10().language), + matching: find.textContaining("German"), + ) + .evaluate() + .isNotEmpty, + reason: "selected language is displayed", + ); + + await settle(tester, settings.setSelectedLocale(null)); + }); + }); + + group("Barcode Settings:", () { + final Map controllerIcons = { + BARCODE_CONTROLLER_CAMERA: TablerIcons.camera, + BARCODE_CONTROLLER_WEDGE: Icons.barcode_reader, + BARCODE_CONTROLLER_INTENT: TablerIcons.arrow_badge_right, + }; + + controllerIcons.forEach((controller, icon) { + testWidgets("Scan Controller ${controller}", (tester) async { + await setSettings(tester, {INV_BARCODE_SCAN_TYPE: controller}); + + await pumpScreen(tester, InvenTreeBarcodeSettingsWidget()); + + await waitUntil( + tester, + () => find + .descendant( + of: tile(L10().barcodeScanController), + matching: find.byIcon(icon), + ) + .evaluate() + .isNotEmpty, + ); + + await removeSettings(tester, [INV_BARCODE_SCAN_TYPE]); + }); + }); + + testWidgets("Scan Delay", (tester) async { + await setSettings(tester, {INV_BARCODE_SCAN_DELAY: 750}); + + await pumpScreen(tester, InvenTreeBarcodeSettingsWidget()); + + await waitUntil(tester, () => find.text("750 ms").evaluate().isNotEmpty); + + // Enter a new value, and check it is limited to the allowed range + final Map values = { + "50": 100, + "1000": 1000, + "99999": 2500, + "abc": 2500, + }; + + for (final entry in values.entries) { + await tester.tap(find.textContaining(" ms")); + await tester.pumpAndSettle(); + + expect(find.byType(AlertDialog), findsOneWidget); + + await tester.enterText( + find.descendant( + of: find.byType(AlertDialog), + matching: find.byType(TextField), + ), + entry.key, + ); + + await tester.tap(find.text(L10().ok)); + await tester.pumpAndSettle(); + + expect(find.byType(AlertDialog), findsNothing); + expect(find.text("${entry.value} ms"), findsOneWidget); + + await waitForSetting(tester, INV_BARCODE_SCAN_DELAY, entry.value); + } + + // Cancel does not change the value + await tester.tap(find.textContaining(" ms")); + await tester.pumpAndSettle(); + + await tester.enterText( + find.descendant( + of: find.byType(AlertDialog), + matching: find.byType(TextField), + ), + "500", + ); + + await tester.tap(find.text(L10().cancel)); + await tester.pumpAndSettle(); + + expect(find.text("2500 ms"), findsOneWidget); + + await removeSettings(tester, [INV_BARCODE_SCAN_DELAY]); + }); + }); + + group("Settings Menu:", () { + testWidgets("Navigation", (tester) async { + await pumpScreen(tester, InvenTreeSettingsWidget()); + + // Each menu item opens the matching settings screen + final Map screens = { + L10().server: InvenTreeSelectServerWidget, + L10().appSettings: InvenTreeAppSettingsWidget, + L10().homeScreen: HomeScreenSettingsWidget, + L10().barcodes: InvenTreeBarcodeSettingsWidget, + L10().part: InvenTreePartSettingsWidget, + L10().stock: InvenTreeStockSettingsWidget, + L10().purchaseOrder: InvenTreePurchaseOrderSettingsWidget, + L10().salesOrder: InvenTreeSalesOrderSettingsWidget, + }; + + for (final entry in screens.entries) { + await tester.tap(tile(entry.key)); + await tester.pumpAndSettle(); + + expect(find.byType(entry.value), findsOneWidget, reason: entry.key); + + // Allow the screen to finish loading, before returning + await waitUntil(tester, () => true); + + OneContext().key.currentState!.pop(); + await tester.pumpAndSettle(); + + expect(find.byType(entry.value), findsNothing); + } + }); + + testWidgets("About", (tester) async { + await pumpScreen(tester, InvenTreeSettingsWidget()); + + await tester.tap(tile(L10().about)); + + await waitUntil( + tester, + () => find.byType(InvenTreeAboutWidget).evaluate().isNotEmpty, + ); + + await tester.pumpAndSettle(); + + expect(find.text(L10().appAbout), findsOneWidget); + expect(find.text(L10().notConnected), findsOneWidget); + expect(find.text("inventree.inventree_app"), findsOneWidget); + expect(find.text("0.0.0 - Build 0"), findsOneWidget); + + // Release notes are loaded from the app assets + await tester.tap(tile(L10().releaseNotes)); + await waitUntil(tester, () => !find.text(L10().appAbout).hasFound); + await tester.pumpAndSettle(); + + expect(find.byType(InvenTreeAboutWidget), findsNothing); + + OneContext().key.currentState!.pop(); + await tester.pumpAndSettle(); + + await tester.tap(tile(L10().credits)); + await waitUntil( + tester, + () => + find.byType(InvenTreeAboutWidget).hitTestable().evaluate().isEmpty, + ); + await tester.pumpAndSettle(); + + OneContext().key.currentState!.pop(); + await tester.pumpAndSettle(); + + expect(find.byType(InvenTreeAboutWidget), findsOneWidget); + + // The update check times out after 10 seconds + await tester.pump(const Duration(seconds: 11)); + }); + + testWidgets("About Widget", (tester) async { + await pumpScreen( + tester, + InvenTreeAboutWidget( + PackageInfo( + appName: "InvenTree", + packageName: "test.package", + version: "1.2.3", + buildNumber: "45", + ), + ), + ); + + expect(find.text("test.package"), findsOneWidget); + expect(find.text("1.2.3 - Build 45"), findsOneWidget); + + await tester.pump(const Duration(seconds: 11)); + }); + }); + + group("Select Server:", () { + late FakeInvenTreeServer server; + + setUp(() async { + server = await FakeInvenTreeServer.start(); + }); + + tearDown(() async { + await server.close(); + }); + + // Create a fresh test profile, pointing at the fake server + Future deleteProfile(WidgetTester tester, String name) async { + final existing = await settle(tester, manager.getProfileByName(name)); + + if (existing != null) { + await settle(tester, manager.deleteProfile(existing)); + } + } + + Future testProfile(WidgetTester tester) async { + for (final name in [profileName, "${profileName} (edited)"]) { + await deleteProfile(tester, name); + } + + await settle( + tester, + manager.addProfile(UserProfile(name: profileName, server: server.url)), + ); + + final UserProfile? profile = await settle( + tester, + manager.getProfileByName(profileName), + ); + + return profile!; + } + + Future pumpSelectServer(WidgetTester tester) async { + await pumpScreen(tester, InvenTreeSelectServerWidget()); + + await waitUntil( + tester, + () => find.text(profileName).evaluate().isNotEmpty, + reason: "profile is listed", + ); + } + + Finder field(String label) => find.widgetWithText(TextFormField, label); + + testWidgets("List Profiles", (tester) async { + await testProfile(tester); + await pumpSelectServer(tester); + + expect(find.text(L10().profileSelect), findsOneWidget); + expect(find.text(server.url), findsOneWidget); + + await deleteProfile(tester, profileName); + }); + + testWidgets("Add Profile", (tester) async { + await testProfile(tester); + await pumpSelectServer(tester); + + const String newName = "${profileName} (new)"; + + await deleteProfile(tester, newName); + + await tester.tap(find.byIcon(TablerIcons.circle_plus)); + await tester.pumpAndSettle(); + + expect(find.text(L10().profileAdd), findsOneWidget); + + Future save() async { + await tester.tap(find.byIcon(TablerIcons.circle_check)); + await tester.pumpAndSettle(); + } + + // Empty values + await save(); + + expect(find.text(L10().valueCannotBeEmpty), findsOneWidget); + expect(find.text(L10().serverEmpty), findsOneWidget); + + await tester.enterText(field(L10().profileName), newName); + + // Invalid server addresses + final Map invalid = { + "http://bad host": L10().invalidHost, + "server.com": L10().invalidHost, + "ftp://server.com": L10().serverStart, + }; + + for (final entry in invalid.entries) { + await tester.enterText(field(L10().server), entry.key); + await save(); + + expect(find.text(entry.value), findsOneWidget, reason: entry.key); + expect(find.text(L10().profileAdd), findsOneWidget); + } + + await tester.enterText(field(L10().server), "https://new.server.com"); + + await tester.tap(find.byIcon(TablerIcons.circle_check)); + + await waitUntil( + tester, + () => find.text(newName).evaluate().isNotEmpty, + reason: "new profile is listed", + ); + + final UserProfile? profile = await settle( + tester, + manager.getProfileByName(newName), + ); + + expect(profile?.server, equals("https://new.server.com")); + + await deleteProfile(tester, newName); + await deleteProfile(tester, profileName); + }); + + testWidgets("Edit Profile", (tester) async { + final profile = await testProfile(tester); + await pumpSelectServer(tester); + + // Open the profile actions menu + await tester.tap( + find.descendant( + of: tile(profileName), + matching: find.byIcon(Icons.more_vert), + ), + ); + await tester.pumpAndSettle(); + + expect(find.text(L10().profileConnect), findsOneWidget); + expect(find.text(L10().profileLogout), findsOneWidget); + expect(find.text(L10().profileDelete), findsOneWidget); + + await tester.tap(find.text(L10().profileEdit)); + await tester.pumpAndSettle(); + + // Existing values are displayed + expect(find.text(L10().profileEdit), findsOneWidget); + expect(find.text(profileName), findsOneWidget); + expect(find.text(server.url), findsOneWidget); + + await tester.enterText( + field(L10().profileName), + "${profileName} (edited)", + ); + + await tester.tap(find.byIcon(TablerIcons.circle_check)); + + await waitUntil( + tester, + () => find.text("${profileName} (edited)").evaluate().isNotEmpty, + reason: "edited profile is listed", + ); + + final UserProfile? edited = await settle( + tester, + manager.getProfileByKey(profile.key!), + ); + + expect(edited?.name, equals("${profileName} (edited)")); + expect(edited?.server, equals(server.url)); + + await deleteProfile(tester, "${profileName} (edited)"); + }); + + testWidgets("Logout Profile", (tester) async { + await testProfile(tester); + await pumpSelectServer(tester); + + // Long press is a shortcut to the actions menu + await tester.longPress(tile(profileName)); + await tester.pumpAndSettle(); + + await tester.tap(find.text(L10().profileLogout)); + + // The profile has no stored session + await waitUntil( + tester, + () => find + .descendant( + of: tile(profileName), + matching: find.byIcon(TablerIcons.user_cancel), + ) + .evaluate() + .isNotEmpty, + ); + + await deleteProfile(tester, profileName); + }); + + testWidgets("Connect Without Session", (tester) async { + await testProfile(tester); + await pumpSelectServer(tester); + + // A profile without a session opens the login screen + await tester.tap(tile(profileName)); + + await waitUntil( + tester, + () => find.byType(InvenTreeLoginWidget).evaluate().isNotEmpty, + reason: "login screen is displayed", + ); + + await tester.pumpAndSettle(); + + OneContext().key.currentState!.pop(); + + await waitUntil( + tester, + () => find.byType(InvenTreeLoginWidget).evaluate().isEmpty, + ); + + await deleteProfile(tester, profileName); + }); + + testWidgets("Connection Check", (tester) async { + await pumpScreen(tester, ProfileEditWidget(null)); + + final Finder checkButton = find.text(L10().connectionCheck); + + Finder statusIcon(IconData icon) => find.descendant( + of: find.byType(ElevatedButton), + matching: find.byIcon(icon), + ); + + expect(statusIcon(TablerIcons.question_mark), findsOneWidget); + + // Invalid form - no check is performed + await tester.tap(checkButton); + await tester.pumpAndSettle(); + + expect(find.text(L10().serverEmpty), findsOneWidget); + expect(server.received("GET", "api/"), isEmpty); + + await tester.enterText(field(L10().profileName), profileName); + await tester.enterText(field(L10().server), server.url); + + await tester.tap(checkButton); + + await waitUntil( + tester, + () => statusIcon(TablerIcons.circle_check).evaluate().isNotEmpty, + reason: "server check passes", + ); + + // Server is not available + final FakeInvenTreeServer closed = await settle( + tester, + FakeInvenTreeServer.start(), + ); + + final String closedUrl = closed.url; + + await settle(tester, closed.close()); + + await tester.enterText(field(L10().server), closedUrl); + await tester.tap(checkButton); + + await waitUntil( + tester, + () => statusIcon(TablerIcons.circle_x).evaluate().isNotEmpty, + reason: "server check fails", + ); + + // Allow the idle HTTP connection (from the first check) to expire + await tester.pump(const Duration(seconds: 16)); + }); + }); +}