diff --git a/assets/release_notes.md b/assets/release_notes.md index 1c06fbd6..15f25876 100644 --- a/assets/release_notes.md +++ b/assets/release_notes.md @@ -3,6 +3,7 @@ - Fix incorrect allocation count in build detail widget - Fix "new version available" notice showing in "About" view when app is up to date +- Fix handling of form response data for stock item creation - Improved allocation display for build orders - Multiple bug fixes for build order support diff --git a/lib/api_form.dart b/lib/api_form.dart index c914acfb..113c33a9 100644 --- a/lib/api_form.dart +++ b/lib/api_form.dart @@ -1101,6 +1101,28 @@ Map extractFieldDefinition( * @param method is the HTTP method to use to send the form data to the server (e.g. POST / PATCH) */ +/* + * Convert a successful form response into a JSON map for the onSuccess callback. + * + * Some endpoints return a list of created objects (e.g. stock item creation + * returns a list since API v383, as multiple serialized items can be created): + * - A single-item list is unwrapped to that item + * - A multi-item list is returned as {"results": [...]} + */ +Map formResponseData(APIResponse response) { + if (response.isList()) { + final List items = response.asList(); + + if (items.length == 1 && items.first is Map) { + return Map.from(items.first as Map); + } + + return {"results": items}; + } + + return Map.from(response.asMap()); +} + Future launchApiForm( BuildContext context, String title, @@ -1550,16 +1572,7 @@ class APIFormWidgetState extends State { case 200: case 201: // Form was successfully validated by the server - // Ensure the response is a valid JSON structure - Map json = {}; - - var responseData = response.asMap(); - - for (String key in responseData.keys) { - json[key.toString()] = responseData[key]; - } - - handleSuccess(data, json); + handleSuccess(data, formResponseData(response)); return; case 400: diff --git a/lib/inventree/stock.dart b/lib/inventree/stock.dart index d30a29f2..0829666d 100644 --- a/lib/inventree/stock.dart +++ b/lib/inventree/stock.dart @@ -9,6 +9,7 @@ import "package:inventree/inventree/part.dart"; import "package:inventree/inventree/model.dart"; import "package:inventree/widget/stock/location_display.dart"; import "package:inventree/widget/stock/stock_detail.dart"; +import "package:inventree/widget/snacks.dart"; /* * Class representing a test result for a single stock item @@ -128,6 +129,30 @@ class InvenTreeStockItem extends InvenTreeModel { // URLs for performing stock actions static String transferStockUrl() => "stock/transfer/"; + /* + * Handle the response after creating new stock item(s) + * (see formResponseData for the response format): + * - A single item: open its detail page + * - Multiple items (e.g. serialized): notify the user and call onMultiple + */ + static void onCreated( + BuildContext context, + Map result, { + Function()? onMultiple, + }) { + if (result.containsKey("pk")) { + InvenTreeStockItem.fromJson(result).goToDetailPage(context); + return; + } + + final dynamic results = result["results"]; + + if (results is List && results.isNotEmpty) { + showSnackIcon(L10().stockItemsCreated(results.length), success: true); + onMultiple?.call(); + } + } + static String countStockUrl() => "stock/count/"; static String addStockUrl() => "stock/add/"; diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index 775f9d8c..c5245037 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -1764,6 +1764,15 @@ "stockItemCreate": "New Stock Item", "@stockItemCreate": {}, + "stockItemsCreated": "{count} stock items created", + "@stockItemsCreated": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "stockItemCreateDetail": "Create new stock item in this location", "@stockItemCreateDetail": {}, diff --git a/lib/widget/part/part_detail.dart b/lib/widget/part/part_detail.dart index f1edf326..156aca83 100644 --- a/lib/widget/part/part_detail.dart +++ b/lib/widget/part/part_detail.dart @@ -836,12 +836,11 @@ class _PartDisplayState extends RefreshableState { fields: fields, data: data, onSuccess: (result) async { - Map data = result as Map; - - if (data.containsKey("pk")) { - var item = InvenTreeStockItem.fromJson(data); - item.goToDetailPage(context); - } + InvenTreeStockItem.onCreated( + context, + result as Map, + onMultiple: () => refresh(context), + ); }, ); } diff --git a/lib/widget/stock/location_display.dart b/lib/widget/stock/location_display.dart index 9f1ace25..1975a77b 100644 --- a/lib/widget/stock/location_display.dart +++ b/lib/widget/stock/location_display.dart @@ -276,12 +276,11 @@ class _LocationDisplayState extends RefreshableState { data: data, fields: fields, onSuccess: (result) async { - Map data = result as Map; - - if (data.containsKey("pk")) { - var item = InvenTreeStockItem.fromJson(data); - item.goToDetailPage(context); - } + InvenTreeStockItem.onCreated( + context, + result as Map, + onMultiple: () => refresh(context), + ); }, ); } diff --git a/test/api_form_test.dart b/test/api_form_test.dart index f2f343b9..01080c62 100644 --- a/test/api_form_test.dart +++ b/test/api_form_test.dart @@ -7,6 +7,53 @@ import "package:inventree/api.dart"; import "package:inventree/api_form.dart"; void main() { + group("Form Response Data:", () { + test("Object", () async { + expect( + formResponseData(APIResponse(statusCode: 201, data: {"pk": 1})), + equals({"pk": 1}), + ); + }); + + // Stock item creation returns a list (API v383+) + test("Single Item List", () async { + expect( + formResponseData( + APIResponse( + statusCode: 201, + data: [ + {"pk": 7, "quantity": 5}, + ], + ), + ), + equals({"pk": 7, "quantity": 5}), + ); + }); + + test("Multiple Item List", () async { + final result = formResponseData( + APIResponse( + statusCode: 201, + data: [ + {"pk": 7}, + {"pk": 8}, + ], + ), + ); + + expect(result.containsKey("pk"), isFalse); + expect(result["results"], hasLength(2)); + }); + + test("Empty", () async { + expect(formResponseData(APIResponse(statusCode: 201)), isEmpty); + expect( + formResponseData(APIResponse(statusCode: 201, data: [])), + equals({"results": []}), + ); + }); + }); + group("Extract Fields:", () { test("Invalid Response", () async { expect(extractFields(APIResponse()), isEmpty); diff --git a/test/widget/detail_test.dart b/test/widget/detail_test.dart index 85540c6a..d2da79f3 100644 --- a/test/widget/detail_test.dart +++ b/test/widget/detail_test.dart @@ -45,35 +45,6 @@ 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. diff --git a/test/widget/harness.dart b/test/widget/harness.dart index 6c010a22..d9fe50da 100644 --- a/test/widget/harness.dart +++ b/test/widget/harness.dart @@ -17,6 +17,7 @@ import "package:flutter_test/flutter_test.dart"; import "package:one_context/one_context.dart"; import "package:inventree/api.dart"; +import "package:inventree/inventree/model.dart"; import "package:inventree/l10n/collected/app_localizations.dart"; import "package:inventree/l10n/supported_locales.dart"; import "package:inventree/preferences.dart"; @@ -152,6 +153,36 @@ Future settle(WidgetTester tester, Future future) async { return value as T; } +/* + * Find the first object matching [filters] on the test server, + * 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; +} + /* * Connect to the test server (see setup.dart) from within a widget test. * @@ -159,7 +190,19 @@ Future settle(WidgetTester tester, Future future) async { * to stop the timers started by the connection. */ Future connectInWidgetTest(WidgetTester tester) async { - await settle(tester, connectToTestServer()); + // The development server may close a kept-alive connection which is then + // reused ("Connection closed before full header was received") - so retry + for (int attempt = 0; attempt < 3; attempt++) { + final profile = await settle(tester, setupServerProfile(login: true)); + + if (await settle(tester, InvenTreeAPI().connectToServer(profile))) { + break; + } + + await tester.runAsync( + () => Future.delayed(const Duration(milliseconds: 500)), + ); + } expect(InvenTreeAPI().isConnected(), isTrue); } diff --git a/test/widget/stock_create_test.dart b/test/widget/stock_create_test.dart new file mode 100644 index 00000000..4e5d3187 --- /dev/null +++ b/test/widget/stock_create_test.dart @@ -0,0 +1,325 @@ +/* + * Widget tests for creating stock items (regression tests for B4). + * + * Since API v383 the server returns a *list* of created stock items, + * which previously caused the app to silently ignore the response. + * + * These tests require a running InvenTree server (see setup.dart) + * with the demo dataset loaded. Any stock items created are deleted again. + */ + +import "package:dropdown_search/dropdown_search.dart"; +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/helpers.dart"; +import "package:inventree/inventree/part.dart"; +import "package:inventree/inventree/stock.dart"; +import "package:inventree/l10.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"; + +/* + * Display [screen], wait for it to load, + * then open the "New Stock Item" form from the actions menu + */ +Future openNewStockItemForm(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); + + // Open the actions menu + await tester.tap(find.byIcon(Icons.more_horiz)); + await idle(tester); + + await tester.tap(find.text(L10().stockItemCreate)); + + // Form fields are loaded from the server (OPTIONS request) + await waitUntil( + tester, + () => find.byType(Form).evaluate().isNotEmpty, + reason: "stock item form displayed", + ); + + await idle(tester); +} + +// Enter [value] into the text field labelled [label] ("*" if required) +Future enterField(WidgetTester tester, String label, String value) async { + final Finder field = find.byWidgetPredicate( + (widget) => + widget is TextField && + (widget.decoration?.labelText == label || + widget.decoration?.labelText == "${label}*"), + ); + + final List labels = tester + .widgetList(find.byType(TextField, skipOffstage: false)) + .map((w) => w.decoration?.labelText) + .toList(); + + expect(field, findsOneWidget, reason: "form field '${label}' in ${labels}"); + + await tester.enterText(field, value); + await tester.pump(); +} + +// Submit the displayed form (save button, after "back", in the app bar) +Future submitForm(WidgetTester tester) async { + await tester.tap( + find + .descendant( + of: find.widgetWithText(AppBar, L10().stockItemCreate), + matching: find.byType(IconButton), + ) + .last, + ); + + await step(tester); +} + +// Snack messages are not displayed in tests, but are logged (see showSnackIcon) +bool snackShown(String message) => + debug_messages.contains("showSnackIcon: '${message}'"); + +// All text currently displayed (for failure messages) +String screenText(WidgetTester tester) => tester + .widgetList(find.byType(Text)) + .map((t) => t.data ?? "") + .where((s) => s.isNotEmpty) + .join(" | "); + +void main() { + setupTestEnv(); + mockSharedPreferences(); + + setUp(() { + OneContext().key = GlobalKey(); + useNewTempDirectory(); + clearDebugMessage(); + }); + + testWidgets("From Location: single item opens", (tester) async { + await withServer(tester, () async { + final location = await fetchFirst( + tester, + InvenTreeStockLocation(), + filters: {"structural": "false"}, + ); + + final part = await fetchFirst( + tester, + InvenTreePart(), + filters: { + "active": "true", + "trackable": "false", + "virtual": "false", + "is_template": "false", + }, + ); + + await openNewStockItemForm(tester, LocationDisplayWidget(location)); + + // Select the part (related field with an online search) + await tester.tap( + find.ancestor( + of: find.text("Part"), + matching: find.byType(DropdownSearch), + ), + ); + await idle(tester); + + await tester.enterText( + find.descendant( + of: find.byType(BottomSheet), + matching: find.byType(TextField), + ), + part.name, + ); + + // The online search runs after a 1 second debounce + await tester.pump(const Duration(seconds: 2)); + + // A search result item (not the search text itself) + final Finder option = find.descendant( + of: find.descendant( + of: find.byType(BottomSheet), + matching: find.byType(InkWell), + ), + matching: find.text(part.fullname), + ); + + // Wait for the search request to complete (loading indicator hidden) + final Finder loading = find.descendant( + of: find.byType(BottomSheet), + matching: find.byType(CircularProgressIndicator), + ); + + await waitUntil( + tester, + () => loading.evaluate().isEmpty && option.evaluate().isNotEmpty, + reason: "part '${part.fullname}' in search: ${screenText(tester)}", + ); + + // Items are rendered inside an IgnorePointer, so the hit test cannot + // resolve to the item itself - the enclosing InkWell handles the tap + await tester.tap( + find.ancestor(of: option.first, matching: find.byType(InkWell)).first, + warnIfMissed: false, + ); + await idle(tester); + + await waitUntil( + tester, + () => find.byType(BottomSheet).evaluate().isEmpty, + reason: "part selected: ${screenText(tester)}", + ); + + await enterField(tester, "Stock Quantity", "1"); + await submitForm(tester); + + // The new stock item is displayed + await waitUntil( + tester, + () => find.byType(StockDetailWidget).evaluate().isNotEmpty, + reason: "new stock item opened: ${screenText(tester)}", + ); + + final StockDetailWidget detail = tester.widget( + find.byType(StockDetailWidget), + ); + + final InvenTreeStockItem item = detail.item; + + try { + expect(item.pk, greaterThan(0)); + expect(item.partId, equals(part.pk)); + expect(item.locationId, equals(location.pk)); + } finally { + // Remove the stock item created by this test + expect(await settle(tester, item.delete()), isTrue); + } + + await idle(tester); + }); + }); + + testWidgets("From Trackable Part: multiple items", (tester) async { + await withServer(tester, () async { + final part = await fetchFirst( + tester, + InvenTreePart(), + filters: { + "active": "true", + "trackable": "true", + "virtual": "false", + "is_template": "false", + }, + ); + + // Find the next available serial number + final APIResponse response = await settle( + tester, + InvenTreeAPI().get( + "part/${part.pk}/serial-numbers/", + expectedStatusCode: 200, + ), + ); + + final int first = + int.tryParse((response.data["next"] ?? "").toString()) ?? 0; + + expect(first, greaterThan(0), reason: "next serial number for ${part}"); + + final List serials = [ + for (int sn = first; sn < first + 3; sn++) sn.toString(), + ]; + + Future> createdItems() async { + final List items = []; + + for (final String serial in serials) { + final results = await InvenTreeStockItem().list( + filters: {"part": part.pk.toString(), "serial": serial}, + ); + + items.addAll(results.whereType()); + } + + return items; + } + + final screen = PartDetailWidget(part); + + try { + await openNewStockItemForm(tester, screen); + + await enterField(tester, "Stock Quantity", "3"); + await enterField( + tester, + "Serial Numbers", + "${serials.first}-${serials.last}", + ); + + await submitForm(tester); + + // User is notified, and remains on the part screen + await waitUntil( + tester, + () => snackShown(L10().stockItemsCreated(3)), + reason: "'stock items created' message: ${screenText(tester)}", + ); + + expect(find.byType(StockDetailWidget), findsNothing); + expect(find.byWidget(screen), findsOneWidget); + + // The part screen is refreshed + final state = + tester.state(find.byWidget(screen)) + as RefreshableState; + + await waitUntil(tester, () => state.loaded, reason: "part reloaded"); + await idle(tester); + + // The stock tab lists the new items + await tester.tap( + find.descendant( + of: find.byType(TabBar), + matching: find.text(L10().stock), + ), + ); + await idle(tester); + + // The (paginated) stock list loads separately from the screen + for (final String serial in serials) { + await waitUntil( + tester, + () => find.textContaining(serial).evaluate().isNotEmpty, + reason: + "serial number ${serial} in stock tab: ${screenText(tester)}", + ); + } + + expect(await settle(tester, createdItems()), hasLength(3)); + } finally { + // Remove any stock items created by this test + for (final item in await settle(tester, createdItems())) { + await settle(tester, item.delete()); + } + } + + await idle(tester); + }); + }); +}