mirror of
https://github.com/inventree/inventree-app.git
synced 2026-11-21 21:25:48 +00:00
More coverage (#905)
* Exclude translation files from coverage * added unit test
This commit is contained in:
1 parent
65cac7218f
commit
db4569ff52
9 files changed
+1779
-1
No files matched your search
@@ -84,6 +84,12 @@ jobs:
|
||||
run: |
|
||||
fvm flutter test --coverage
|
||||
|
||||
# Generated translation files are not exercised by tests, and swamp the coverage report
|
||||
- name: Exclude Translation Files from Coverage
|
||||
run: |
|
||||
awk '/^SF:/ { skip = ($0 ~ /lib\/l10n\//) } !skip; /^end_of_record/ { skip = 0 }' coverage/lcov.info > coverage/lcov.filtered.info
|
||||
mv coverage/lcov.filtered.info coverage/lcov.info
|
||||
|
||||
- name: Coveralls
|
||||
uses: coverallsapp/github-action@master
|
||||
with:
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
- Expired sessions now return the user to the login screen
|
||||
- Credentials are removed from error reports
|
||||
- Requires InvenTree server API version 314 or newer - existing users must log in again
|
||||
- Updated translations
|
||||
|
||||
## 0.26.0 - October 2026
|
||||
---
|
||||
|
||||
+5
-1
@@ -40,7 +40,11 @@ Map<String, dynamic> extractFields(APIResponse response) {
|
||||
|
||||
var actions = response.data["actions"] as Map<String, dynamic>;
|
||||
|
||||
dynamic result = actions["POST"] ?? actions["PUT"] ?? actions["PATCH"] ?? {};
|
||||
dynamic result =
|
||||
actions["POST"] ??
|
||||
actions["PUT"] ??
|
||||
actions["PATCH"] ??
|
||||
<String, dynamic>{};
|
||||
|
||||
return result as Map<String, dynamic>;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,271 @@
|
||||
/*
|
||||
* Unit tests for APIFormField (no server or widgets required)
|
||||
*/
|
||||
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/api.dart";
|
||||
import "package:inventree/api_form.dart";
|
||||
|
||||
void main() {
|
||||
group("Extract Fields:", () {
|
||||
test("Invalid Response", () async {
|
||||
expect(extractFields(APIResponse()), isEmpty);
|
||||
expect(extractFields(APIResponse(statusCode: 500)), isEmpty);
|
||||
});
|
||||
|
||||
test("No Actions", () async {
|
||||
expect(
|
||||
extractFields(APIResponse(statusCode: 200, data: {"name": "x"})),
|
||||
isEmpty,
|
||||
);
|
||||
|
||||
expect(
|
||||
extractFields(
|
||||
APIResponse(statusCode: 200, data: {"actions": <String, dynamic>{}}),
|
||||
),
|
||||
isEmpty,
|
||||
);
|
||||
});
|
||||
|
||||
test("Action Priority", () async {
|
||||
Map<String, dynamic> fields(Map<String, dynamic> actions) =>
|
||||
extractFields(
|
||||
APIResponse(statusCode: 200, data: {"actions": actions}),
|
||||
);
|
||||
|
||||
expect(
|
||||
fields({
|
||||
"POST": {"a": {}},
|
||||
"PUT": {"b": {}},
|
||||
}).keys,
|
||||
equals(["a"]),
|
||||
);
|
||||
|
||||
expect(
|
||||
fields({
|
||||
"PUT": {"b": {}},
|
||||
"PATCH": {"c": {}},
|
||||
}).keys,
|
||||
equals(["b"]),
|
||||
);
|
||||
|
||||
expect(
|
||||
fields({
|
||||
"PATCH": {"c": {}},
|
||||
}).keys,
|
||||
equals(["c"]),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
group("Form Field:", () {
|
||||
test("Defaults", () async {
|
||||
final field = APIFormField("name", {});
|
||||
|
||||
expect(field.pk_field, equals("pk"));
|
||||
expect(field.api_url, equals(""));
|
||||
expect(field.model, equals(""));
|
||||
expect(field.hidden, isFalse);
|
||||
expect(field.nested, isFalse);
|
||||
expect(field.parent, equals(""));
|
||||
expect(field.isSimple, isTrue);
|
||||
expect(field.readOnly, isFalse);
|
||||
expect(field.multiline, isFalse);
|
||||
expect(field.required, isFalse);
|
||||
expect(field.type, equals(""));
|
||||
expect(field.label, equals(""));
|
||||
expect(field.helpText, equals(""));
|
||||
expect(field.placeholderText, equals(""));
|
||||
expect(field.choices, isEmpty);
|
||||
expect(field.value, isNull);
|
||||
expect(field.defaultValue, isNull);
|
||||
expect(field.filters, isEmpty);
|
||||
expect(field.hasErrors(), isFalse);
|
||||
expect(field.renderValueToString(), equals(""));
|
||||
});
|
||||
|
||||
test("Parameters", () async {
|
||||
final field = APIFormField("part", {"label": "Local Label"});
|
||||
|
||||
field.definition = {
|
||||
"label": "Server Label",
|
||||
"help_text": "Select a part",
|
||||
"type": "related field",
|
||||
"required": true,
|
||||
"read_only": false,
|
||||
"model": "part",
|
||||
"api_url": "/api/part/",
|
||||
"placeholder": "Part",
|
||||
"choices": [
|
||||
{"value": 1, "display_name": "One"},
|
||||
],
|
||||
};
|
||||
|
||||
// Local data takes priority over the server definition
|
||||
expect(field.label, equals("Local Label"));
|
||||
|
||||
expect(field.helpText, equals("Select a part"));
|
||||
expect(field.type, equals("related field"));
|
||||
expect(field.required, isTrue);
|
||||
expect(field.readOnly, isFalse);
|
||||
expect(field.model, equals("part"));
|
||||
expect(field.api_url, equals("/api/part/"));
|
||||
expect(field.placeholderText, equals("Part"));
|
||||
expect(field.choices.length, equals(1));
|
||||
expect(field.getParameter("missing"), isNull);
|
||||
});
|
||||
|
||||
test("Value", () async {
|
||||
final field = APIFormField("quantity", {});
|
||||
|
||||
field.definition = {"default": 1};
|
||||
expect(field.value, equals(1));
|
||||
|
||||
field.data["instance_value"] = 5;
|
||||
expect(field.value, equals(5));
|
||||
|
||||
// Value is not rendered from the default or instance value
|
||||
expect(field.renderValueToString(), equals(""));
|
||||
|
||||
field.setFieldValue(10);
|
||||
expect(field.value, equals(10));
|
||||
expect(field.renderValueToString(), equals("10"));
|
||||
});
|
||||
|
||||
test("Lookup Path", () async {
|
||||
expect(APIFormField("name", {}).lookupPath, equals("name"));
|
||||
|
||||
expect(
|
||||
APIFormField("quantity", {"parent": "items"}).lookupPath,
|
||||
equals("items.child"),
|
||||
);
|
||||
|
||||
expect(
|
||||
APIFormField("quantity", {"nested": true}).lookupPath,
|
||||
equals("children.quantity"),
|
||||
);
|
||||
|
||||
final field = APIFormField("quantity", {
|
||||
"parent": "items",
|
||||
"nested": true,
|
||||
});
|
||||
|
||||
expect(field.isSimple, isFalse);
|
||||
expect(field.lookupPath, equals("items.child.children.quantity"));
|
||||
});
|
||||
|
||||
test("Filters", () async {
|
||||
final field = APIFormField("location", {
|
||||
"filters": {"structural": false, "parent": 3},
|
||||
});
|
||||
|
||||
field.definition = {
|
||||
"filters": {"active": true, "parent": 1},
|
||||
"instance_filters": {"category": 2},
|
||||
};
|
||||
|
||||
// Filters are merged, with local filters taking priority
|
||||
expect(
|
||||
field.filters,
|
||||
equals({
|
||||
"active": "true",
|
||||
"parent": "3",
|
||||
"category": "2",
|
||||
"structural": "false",
|
||||
}),
|
||||
);
|
||||
|
||||
// Malformed filters are ignored
|
||||
final invalid = APIFormField("location", {"filters": "invalid"});
|
||||
invalid.definition = {"filters": 1, "instance_filters": []};
|
||||
|
||||
expect(invalid.filters, isEmpty);
|
||||
});
|
||||
});
|
||||
|
||||
group("Form Field Errors:", () {
|
||||
test("Simple Field", () async {
|
||||
final field = APIFormField("name", {});
|
||||
|
||||
field.extractErrorMessages(
|
||||
APIResponse(
|
||||
statusCode: 400,
|
||||
data: {
|
||||
"name": ["This field is required", "Too short"],
|
||||
},
|
||||
),
|
||||
);
|
||||
|
||||
expect(field.hasErrors(), isTrue);
|
||||
expect(
|
||||
field.errorMessages(),
|
||||
equals(["This field is required", "Too short"]),
|
||||
);
|
||||
|
||||
// Single string error message
|
||||
field.extractErrorMessages(
|
||||
APIResponse(statusCode: 400, data: {"name": "Invalid name"}),
|
||||
);
|
||||
|
||||
expect(field.errorMessages(), equals(["Invalid name"]));
|
||||
|
||||
// No error for this field
|
||||
field.extractErrorMessages(
|
||||
APIResponse(statusCode: 400, data: {"other": "error"}),
|
||||
);
|
||||
|
||||
expect(field.hasErrors(), isFalse);
|
||||
});
|
||||
|
||||
test("Nested Field", () async {
|
||||
final field = APIFormField("quantity", {
|
||||
"parent": "items",
|
||||
"nested": true,
|
||||
});
|
||||
|
||||
// Errors returned as a list (one entry per nested item)
|
||||
field.extractErrorMessages(
|
||||
APIResponse(
|
||||
statusCode: 400,
|
||||
data: {
|
||||
"items": [
|
||||
{
|
||||
"quantity": ["Must be positive"],
|
||||
},
|
||||
],
|
||||
},
|
||||
),
|
||||
);
|
||||
|
||||
expect(field.errorMessages(), equals(["Must be positive"]));
|
||||
|
||||
// Errors returned as a map
|
||||
field.extractErrorMessages(
|
||||
APIResponse(
|
||||
statusCode: 400,
|
||||
data: {
|
||||
"items": {"quantity": "Invalid quantity"},
|
||||
},
|
||||
),
|
||||
);
|
||||
|
||||
expect(field.errorMessages(), equals(["Invalid quantity"]));
|
||||
|
||||
// Parent element is missing
|
||||
field.extractErrorMessages(APIResponse(statusCode: 400, data: {}));
|
||||
|
||||
expect(field.hasErrors(), isFalse);
|
||||
});
|
||||
|
||||
test("Nested Field Without Parent", () async {
|
||||
// A nested field with no parent cannot be matched to errors
|
||||
final field = APIFormField("quantity", {"nested": true});
|
||||
|
||||
field.extractErrorMessages(
|
||||
APIResponse(statusCode: 400, data: {"quantity": "error"}),
|
||||
);
|
||||
|
||||
expect(field.hasErrors(), isFalse);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
/*
|
||||
* Unit tests for the helper functions in helpers.dart
|
||||
*/
|
||||
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/helpers.dart";
|
||||
|
||||
void main() {
|
||||
group("Number Helpers:", () {
|
||||
test("Simple Number String", () async {
|
||||
expect(simpleNumberString(0), equals("0"));
|
||||
expect(simpleNumberString(10), equals("10"));
|
||||
expect(simpleNumberString(-3), equals("-3"));
|
||||
expect(simpleNumberString(1.5), equals("1.5"));
|
||||
expect(simpleNumberString(0.25), equals("0.25"));
|
||||
});
|
||||
|
||||
test("Valid Number", () async {
|
||||
expect(isValidNumber(1.0), isTrue);
|
||||
expect(isValidNumber(0), isTrue);
|
||||
expect(isValidNumber(-1.5), isTrue);
|
||||
expect(isValidNumber(null), isFalse);
|
||||
expect(isValidNumber(double.nan), isFalse);
|
||||
expect(isValidNumber(double.infinity), isFalse);
|
||||
expect(isValidNumber(double.negativeInfinity), isFalse);
|
||||
});
|
||||
});
|
||||
|
||||
group("Currency Helpers:", () {
|
||||
test("Invalid Values", () async {
|
||||
expect(renderCurrency(null, "USD"), equals("-"));
|
||||
expect(renderCurrency(double.nan, "USD"), equals("-"));
|
||||
expect(renderCurrency(double.infinity, "USD"), equals("-"));
|
||||
expect(renderCurrency(10, ""), equals("-"));
|
||||
expect(renderCurrency(10, " "), equals("-"));
|
||||
});
|
||||
|
||||
test("Render Currency", () async {
|
||||
String usd = renderCurrency(12.5, "USD");
|
||||
expect(usd, contains("\$"));
|
||||
expect(usd, contains("12.50"));
|
||||
|
||||
// Currency code is case insensitive, and whitespace is ignored
|
||||
expect(renderCurrency(12.5, " usd "), equals(usd));
|
||||
|
||||
// Unknown currency codes fall back to USD formatting
|
||||
expect(renderCurrency(12.5, "XYZ"), equals(usd));
|
||||
|
||||
expect(renderCurrency(12.5, "EUR"), contains("€"));
|
||||
});
|
||||
|
||||
test("Price Range", () async {
|
||||
String low = renderCurrency(1, "USD");
|
||||
String high = renderCurrency(2, "USD");
|
||||
|
||||
expect(formatPriceRange(null, null), equals("-"));
|
||||
expect(formatPriceRange(double.nan, double.infinity), equals("-"));
|
||||
|
||||
expect(formatPriceRange(1, 1), equals(low));
|
||||
expect(formatPriceRange(1, 2), equals("${low} - ${high}"));
|
||||
|
||||
// Only one valid value
|
||||
expect(formatPriceRange(1, null), equals(low));
|
||||
expect(formatPriceRange(null, 2), equals(high));
|
||||
expect(formatPriceRange(double.nan, 2), equals(high));
|
||||
|
||||
// Currency is passed through
|
||||
expect(
|
||||
formatPriceRange(1, 2, currency: "EUR"),
|
||||
equals("${renderCurrency(1, "EUR")} - ${renderCurrency(2, "EUR")}"),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
group("Debug Helpers:", () {
|
||||
test("Debug Messages", () async {
|
||||
expect(isTesting(), isTrue);
|
||||
expect(hasContext(), isFalse);
|
||||
|
||||
int count = debugMessageCount();
|
||||
|
||||
debug("helpers_test: a unique message");
|
||||
|
||||
expect(debugMessageCount(), equals(count + 1));
|
||||
expect(debugContains("helpers_test: a unique message"), isTrue);
|
||||
expect(
|
||||
debugContains("helpers_test: missing", raiseAssert: false),
|
||||
isFalse,
|
||||
);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
/*
|
||||
* Unit tests for parsing of managed (MDM) configuration values
|
||||
*/
|
||||
|
||||
import "package:flutter/material.dart";
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/managed_config.dart";
|
||||
|
||||
void main() {
|
||||
group("Managed Setting:", () {
|
||||
test("Null Value", () async {
|
||||
for (final type in ManagedSettingType.values) {
|
||||
expect(ManagedSetting("key", type).parse(null), isNull);
|
||||
}
|
||||
});
|
||||
|
||||
test("Boolean", () async {
|
||||
const setting = ManagedSetting("key", ManagedSettingType.boolean);
|
||||
|
||||
for (final value in [true, "true", " TRUE ", "1", 1, "yes", "On"]) {
|
||||
expect(setting.parse(value), isTrue, reason: "value: '${value}'");
|
||||
}
|
||||
|
||||
for (final value in [false, "false", "0", 0, "No", "off"]) {
|
||||
expect(setting.parse(value), isFalse, reason: "value: '${value}'");
|
||||
}
|
||||
|
||||
for (final value in ["", "maybe", 2, "truthy"]) {
|
||||
expect(setting.parse(value), isNull, reason: "value: '${value}'");
|
||||
}
|
||||
});
|
||||
|
||||
test("Integer", () async {
|
||||
const setting = ManagedSetting("key", ManagedSettingType.integer);
|
||||
|
||||
expect(setting.parse(5), equals(5));
|
||||
expect(setting.parse(7.9), equals(7));
|
||||
expect(setting.parse(" 42 "), equals(42));
|
||||
expect(setting.parse("-3"), equals(-3));
|
||||
expect(setting.parse("abc"), isNull);
|
||||
expect(setting.parse("1.5"), isNull);
|
||||
});
|
||||
|
||||
test("Integer Limits", () async {
|
||||
const setting = ManagedSetting(
|
||||
"key",
|
||||
ManagedSettingType.integer,
|
||||
minimum: 1,
|
||||
maximum: 10,
|
||||
);
|
||||
|
||||
expect(setting.parse(5), equals(5));
|
||||
expect(setting.parse(0), equals(1));
|
||||
expect(setting.parse("-100"), equals(1));
|
||||
expect(setting.parse(11), equals(10));
|
||||
expect(setting.parse("1000"), equals(10));
|
||||
});
|
||||
|
||||
test("Choice", () async {
|
||||
const setting = ManagedSetting(
|
||||
"key",
|
||||
ManagedSettingType.choice,
|
||||
choices: {"System": 0, "portrait": 1, "landscape": 2},
|
||||
);
|
||||
|
||||
// Match by name (case insensitive)
|
||||
expect(setting.parse("system"), equals(0));
|
||||
expect(setting.parse(" PORTRAIT "), equals(1));
|
||||
expect(setting.parse("Landscape"), equals(2));
|
||||
|
||||
// Match by value
|
||||
expect(setting.parse(2), equals(2));
|
||||
expect(setting.parse("1"), equals(1));
|
||||
|
||||
// No match
|
||||
expect(setting.parse("sideways"), isNull);
|
||||
expect(setting.parse(3), isNull);
|
||||
expect(setting.parse("-1"), isNull);
|
||||
});
|
||||
|
||||
test("Managed Settings List", () async {
|
||||
// Every managed setting must have a unique key
|
||||
final keys = MANAGED_SETTINGS.map((s) => s.key).toList();
|
||||
expect(keys.toSet().length, equals(keys.length));
|
||||
|
||||
for (final setting in MANAGED_SETTINGS) {
|
||||
if (setting.type == ManagedSettingType.choice) {
|
||||
expect(setting.choices, isNotEmpty, reason: setting.key);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
group("Managed Locale:", () {
|
||||
test("Exact Match", () async {
|
||||
expect(matchSupportedLocale("de_DE"), equals(const Locale("de", "DE")));
|
||||
expect(matchSupportedLocale("pt-PT"), equals(const Locale("pt", "PT")));
|
||||
expect(matchSupportedLocale("zh_tw"), equals(const Locale("zh", "TW")));
|
||||
expect(matchSupportedLocale(" en "), equals(const Locale("en", "")));
|
||||
});
|
||||
|
||||
test("Language Match", () async {
|
||||
// Falls back to the first supported locale for the language
|
||||
expect(matchSupportedLocale("fr"), equals(const Locale("fr", "FR")));
|
||||
expect(matchSupportedLocale("ES"), equals(const Locale("es", "ES")));
|
||||
});
|
||||
|
||||
test("No Match", () async {
|
||||
expect(matchSupportedLocale(""), isNull);
|
||||
expect(matchSupportedLocale(" "), isNull);
|
||||
expect(matchSupportedLocale("xx"), isNull);
|
||||
expect(matchSupportedLocale("xx_YY"), isNull);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,583 @@
|
||||
/*
|
||||
* Unit tests for model classes constructed from JSON data
|
||||
*
|
||||
* These tests do not require a connection to the server
|
||||
*/
|
||||
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/api.dart";
|
||||
import "package:inventree/inventree/model.dart";
|
||||
import "package:inventree/inventree/orders.dart";
|
||||
import "package:inventree/inventree/part.dart";
|
||||
import "package:inventree/inventree/stock.dart";
|
||||
import "package:inventree/l10.dart";
|
||||
|
||||
void main() {
|
||||
group("Model Accessors:", () {
|
||||
test("Empty Data", () async {
|
||||
final model = InvenTreeModel.fromJson({});
|
||||
|
||||
expect(model.pk, equals(-1));
|
||||
expect(model.name, equals(""));
|
||||
expect(model.description, equals(""));
|
||||
expect(model.getString("missing", backup: "x"), equals("x"));
|
||||
expect(model.getInt("missing", backup: 7), equals(7));
|
||||
expect(model.getDouble("missing"), equals(0.0));
|
||||
expect(model.getDoubleOrNull("missing"), isNull);
|
||||
expect(model.getBool("missing"), isFalse);
|
||||
expect(model.getBool("missing", backup: true), isTrue);
|
||||
expect(model.getDate("missing"), isNull);
|
||||
expect(model.getDateString("missing"), equals(""));
|
||||
expect(model.getMap("missing"), isEmpty);
|
||||
expect(model.link, equals(""));
|
||||
expect(model.hasLink, isFalse);
|
||||
expect(model.customIcon, isNull);
|
||||
expect(model.customBarcode, equals(""));
|
||||
expect(model.reloadedWithin(const Duration(days: 1)), isFalse);
|
||||
});
|
||||
|
||||
test("Typed Values", () async {
|
||||
final model = InvenTreeModel.fromJson({
|
||||
"pk": 12,
|
||||
"name": "Widget",
|
||||
"count": "42",
|
||||
"bad_int": "abc",
|
||||
"ratio": "1.5",
|
||||
"bad_double": "x",
|
||||
"flag": "True",
|
||||
"not_flag": "yes",
|
||||
"null_value": null,
|
||||
"date": "2024-03-07T10:15:00Z",
|
||||
"detail": {"name": "Sub", "count": 3},
|
||||
});
|
||||
|
||||
expect(model.pk, equals(12));
|
||||
expect(model.pkString, equals("12"));
|
||||
expect(model.name, equals("Widget"));
|
||||
|
||||
expect(model.getInt("count"), equals(42));
|
||||
expect(model.getInt("bad_int"), equals(-1));
|
||||
expect(model.getDouble("ratio"), equals(1.5));
|
||||
expect(model.getDoubleOrNull("bad_double"), isNull);
|
||||
expect(model.getBool("flag"), isTrue);
|
||||
expect(model.getBool("not_flag"), isFalse);
|
||||
|
||||
// Explicit null values return the backup
|
||||
expect(model.getString("null_value", backup: "b"), equals("b"));
|
||||
expect(model.getInt("null_value", backup: 3), equals(3));
|
||||
expect(model.getBool("null_value", backup: true), isTrue);
|
||||
expect(model.getMap("null_value"), isEmpty);
|
||||
|
||||
expect(model.getDate("date")?.year, equals(2024));
|
||||
expect(model.getDateString("date"), equals("2024-03-07"));
|
||||
|
||||
// Sub-key lookups
|
||||
expect(model.getString("name", subKey: "detail"), equals("Sub"));
|
||||
expect(model.getInt("count", subKey: "detail"), equals(3));
|
||||
expect(model.getMap("detail")["name"], equals("Sub"));
|
||||
expect(
|
||||
model.getString("name", subKey: "missing", backup: "none"),
|
||||
equals("none"),
|
||||
);
|
||||
|
||||
model.setValue("name", "Gadget");
|
||||
expect(model.name, equals("Gadget"));
|
||||
});
|
||||
|
||||
test("Status", () async {
|
||||
var model = InvenTreeModel.fromJson({"status": 10});
|
||||
|
||||
expect(model.status, equals(10));
|
||||
expect(model.hasCustomStatus, isFalse);
|
||||
|
||||
model = InvenTreeModel.fromJson({"status": 10, "status_custom_key": 101});
|
||||
|
||||
expect(model.logicalStatus, equals(10));
|
||||
expect(model.customStatus, equals(101));
|
||||
expect(model.status, equals(101));
|
||||
});
|
||||
|
||||
test("Link", () async {
|
||||
expect(
|
||||
InvenTreeModel.fromJson({"link": "https://a.com"}).link,
|
||||
equals("https://a.com"),
|
||||
);
|
||||
|
||||
// Legacy API used "URL"
|
||||
final legacy = InvenTreeModel.fromJson({"URL": "https://b.com"});
|
||||
expect(legacy.link, equals("https://b.com"));
|
||||
expect(legacy.hasLink, isTrue);
|
||||
});
|
||||
|
||||
test("Custom Icon", () async {
|
||||
expect(InvenTreeModel.fromJson({"icon": " "}).customIcon, isNull);
|
||||
expect(InvenTreeModel.fromJson({"icon": "fa:box"}).customIcon, isNull);
|
||||
expect(InvenTreeModel.fromJson({"icon": "ti:"}).customIcon, isNull);
|
||||
expect(
|
||||
InvenTreeModel.fromJson({"icon": "ti:not-an-icon:outline"}).customIcon,
|
||||
isNull,
|
||||
);
|
||||
expect(
|
||||
InvenTreeModel.fromJson({"icon": "ti:box:outline"}).customIcon,
|
||||
isNotNull,
|
||||
);
|
||||
expect(
|
||||
InvenTreeModel.fromJson({"icon": "ti:arrow-left:outline"}).customIcon,
|
||||
isNotNull,
|
||||
);
|
||||
});
|
||||
|
||||
test("Custom Barcode", () async {
|
||||
expect(
|
||||
InvenTreeModel.fromJson({
|
||||
"uid": "abc",
|
||||
"barcode_hash": "def",
|
||||
}).customBarcode,
|
||||
equals("abc"),
|
||||
);
|
||||
expect(
|
||||
InvenTreeModel.fromJson({
|
||||
"barcode_hash": "def",
|
||||
"barcode": "ghi",
|
||||
}).customBarcode,
|
||||
equals("def"),
|
||||
);
|
||||
expect(
|
||||
InvenTreeModel.fromJson({"barcode": "ghi"}).customBarcode,
|
||||
equals("ghi"),
|
||||
);
|
||||
});
|
||||
|
||||
test("Detail URL", () async {
|
||||
final part = InvenTreePart.fromJson({"pk": 5});
|
||||
expect(part.url, equals("part/5/"));
|
||||
|
||||
final item = InvenTreeStockItem.fromJson({"pk": 9});
|
||||
expect(item.url, equals("stock/9/"));
|
||||
});
|
||||
|
||||
test("Reloaded Within", () async {
|
||||
final model = InvenTreeModel.fromJson({});
|
||||
|
||||
model.lastReload = DateTime.now();
|
||||
expect(model.reloadedWithin(const Duration(minutes: 1)), isTrue);
|
||||
|
||||
model.lastReload = DateTime.now().subtract(const Duration(hours: 1));
|
||||
expect(model.reloadedWithin(const Duration(minutes: 1)), isFalse);
|
||||
});
|
||||
});
|
||||
|
||||
group("Part Category:", () {
|
||||
test("Path", () async {
|
||||
var category = InvenTreePartCategory.fromJson({
|
||||
"pathstring": "Electronics/Passives/Resistors",
|
||||
});
|
||||
|
||||
expect(category.parentPathString, equals("Electronics/Passives"));
|
||||
|
||||
category = InvenTreePartCategory.fromJson({"pathstring": "Electronics"});
|
||||
|
||||
expect(category.parentPathString, equals(L10().partCategoryTopLevel));
|
||||
});
|
||||
|
||||
test("Part Count", () async {
|
||||
expect(InvenTreePartCategory.fromJson({}).partcount, equals(0));
|
||||
expect(
|
||||
InvenTreePartCategory.fromJson({"part_count": 4}).partcount,
|
||||
equals(4),
|
||||
);
|
||||
|
||||
// Legacy API used "parts"
|
||||
expect(InvenTreePartCategory.fromJson({"parts": 3}).partcount, equals(3));
|
||||
});
|
||||
});
|
||||
|
||||
group("Part:", () {
|
||||
test("Full Name", () async {
|
||||
expect(
|
||||
InvenTreePart.fromJson({
|
||||
"full_name": "IPN | Name",
|
||||
"name": "x",
|
||||
}).fullname,
|
||||
equals("IPN | Name"),
|
||||
);
|
||||
|
||||
expect(
|
||||
InvenTreePart.fromJson({"name": "Widget"}).fullname,
|
||||
equals("Widget"),
|
||||
);
|
||||
|
||||
expect(
|
||||
InvenTreePart.fromJson({
|
||||
"name": "Widget",
|
||||
"IPN": "W-001",
|
||||
"revision": "B",
|
||||
}).fullname,
|
||||
equals("W-001 | Widget | B"),
|
||||
);
|
||||
});
|
||||
|
||||
test("Stock", () async {
|
||||
var part = InvenTreePart.fromJson({"in_stock": 10});
|
||||
|
||||
expect(part.inStock, equals(10));
|
||||
expect(part.unallocatedStock, equals(10));
|
||||
expect(part.stockString(), equals("10"));
|
||||
|
||||
part = InvenTreePart.fromJson({
|
||||
"in_stock": 1,
|
||||
"total_in_stock": 12.5,
|
||||
"unallocated_stock": "4",
|
||||
"units": "m",
|
||||
"ordering": 3,
|
||||
});
|
||||
|
||||
expect(part.inStock, equals(12.5));
|
||||
expect(part.inStockString, equals("12.5"));
|
||||
expect(part.unallocatedStock, equals(4));
|
||||
expect(part.stockString(), equals("4 / 12.5 m"));
|
||||
expect(part.stockString(includeUnits: false), equals("4 / 12.5"));
|
||||
expect(part.onOrderString, equals("3"));
|
||||
|
||||
// Available stock cannot be negative
|
||||
part = InvenTreePart.fromJson({"in_stock": 1, "unallocated_stock": -5});
|
||||
|
||||
expect(part.unallocatedStock, equals(0));
|
||||
});
|
||||
|
||||
test("Category", () async {
|
||||
final detail = {"name": "Resistors", "description": "Fixed resistors"};
|
||||
|
||||
var part = InvenTreePart.fromJson({
|
||||
"category": 4,
|
||||
"category_detail": detail,
|
||||
});
|
||||
|
||||
expect(part.categoryId, equals(4));
|
||||
expect(part.categoryName, equals("Resistors"));
|
||||
expect(part.categoryDescription, equals("Fixed resistors"));
|
||||
|
||||
// Missing detail
|
||||
part = InvenTreePart.fromJson({"category": 4});
|
||||
expect(part.categoryName, equals(""));
|
||||
expect(part.categoryDescription, equals(""));
|
||||
|
||||
// No category
|
||||
part = InvenTreePart.fromJson({"category_detail": detail});
|
||||
expect(part.categoryName, equals(""));
|
||||
expect(part.categoryDescription, equals(""));
|
||||
});
|
||||
|
||||
test("Images", () async {
|
||||
var part = InvenTreePart.fromJson({});
|
||||
expect(part.image, equals(InvenTreeAPI.staticImage));
|
||||
expect(part.thumbnail, equals(InvenTreeAPI.staticThumb));
|
||||
|
||||
part = InvenTreePart.fromJson({"image": "/media/a.png"});
|
||||
expect(part.image, equals("/media/a.png"));
|
||||
expect(part.thumbnail, equals("/media/a.png"));
|
||||
|
||||
part = InvenTreePart.fromJson({"thumbnail": "/media/a.thumb.png"});
|
||||
expect(part.image, equals("/media/a.thumb.png"));
|
||||
expect(part.thumbnail, equals("/media/a.thumb.png"));
|
||||
});
|
||||
|
||||
test("Attributes", () async {
|
||||
final part = InvenTreePart.fromJson({
|
||||
"assembly": true,
|
||||
"component": false,
|
||||
"purchaseable": true,
|
||||
"salable": false,
|
||||
"active": true,
|
||||
"virtual": false,
|
||||
"is_template": true,
|
||||
"trackable": true,
|
||||
"testable": false,
|
||||
"starred": true,
|
||||
"used_in": 6,
|
||||
"variant_of": 2,
|
||||
"default_location": 8,
|
||||
});
|
||||
|
||||
expect(part.isAssembly, isTrue);
|
||||
expect(part.isComponent, isFalse);
|
||||
expect(part.isPurchaseable, isTrue);
|
||||
expect(part.isSalable, isFalse);
|
||||
expect(part.isActive, isTrue);
|
||||
expect(part.isVirtual, isFalse);
|
||||
expect(part.isTemplate, isTrue);
|
||||
expect(part.isTrackable, isTrue);
|
||||
expect(part.isTestable, isFalse);
|
||||
expect(part.starred, isTrue);
|
||||
expect(part.usedInCount, equals(6));
|
||||
expect(part.variantOf, equals(2));
|
||||
expect(part.defaultLocation, equals(8));
|
||||
|
||||
expect(InvenTreePart.fromJson({}).usedInCount, equals(0));
|
||||
});
|
||||
|
||||
test("Pricing", () async {
|
||||
var pricing = InvenTreePartPricing.fromJson({});
|
||||
|
||||
expect(pricing.currency, equals("USD"));
|
||||
expect(pricing.overallMin, isNull);
|
||||
|
||||
pricing = InvenTreePartPricing.fromJson({
|
||||
"currency": "AUD",
|
||||
"overall_min": "1.25",
|
||||
"overall_max": 3,
|
||||
});
|
||||
|
||||
expect(pricing.currency, equals("AUD"));
|
||||
expect(pricing.overallMin, equals(1.25));
|
||||
expect(pricing.overallMax, equals(3));
|
||||
});
|
||||
});
|
||||
|
||||
group("Stock Item:", () {
|
||||
test("Quantity", () async {
|
||||
var item = InvenTreeStockItem.fromJson({"quantity": 10});
|
||||
|
||||
expect(item.isSerialized(), isFalse);
|
||||
expect(item.quantityString(), equals("10"));
|
||||
expect(item.serialOrQuantityDisplay(), equals("10"));
|
||||
expect(item.displayQuantity, equals("10"));
|
||||
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"quantity": 10,
|
||||
"allocated": 4,
|
||||
"part_detail": {"units": "kg"},
|
||||
});
|
||||
|
||||
expect(item.available, equals(6));
|
||||
expect(item.quantityString(), equals("6 / 10 kg"));
|
||||
expect(item.quantityString(includeUnits: false), equals("6 / 10"));
|
||||
expect(item.serialOrQuantityDisplay(), equals("6.0 / 10.0"));
|
||||
expect(item.displayQuantity, equals("10 kg"));
|
||||
});
|
||||
|
||||
test("Serial Number", () async {
|
||||
var item = InvenTreeStockItem.fromJson({"quantity": 1, "serial": "123"});
|
||||
|
||||
expect(item.isSerialized(), isTrue);
|
||||
expect(item.serialOrQuantityDisplay(), equals("SN 123"));
|
||||
expect(item.displayQuantity, equals("SN: 123"));
|
||||
|
||||
// Serial number with quantity > 1 is not considered serialized
|
||||
item = InvenTreeStockItem.fromJson({"quantity": 2, "serial": "123"});
|
||||
expect(item.isSerialized(), isFalse);
|
||||
});
|
||||
|
||||
test("Part Information", () async {
|
||||
var item = InvenTreeStockItem.fromJson({
|
||||
"part_detail": {
|
||||
"full_name": "Widget | A",
|
||||
"description": "A widget",
|
||||
"thumbnail": "/media/w.thumb.png",
|
||||
},
|
||||
});
|
||||
|
||||
expect(item.partName, equals("Widget | A"));
|
||||
expect(item.partDescription, equals("A widget"));
|
||||
expect(item.partImage, equals("/media/w.thumb.png"));
|
||||
expect(item.partThumbnail, equals("/media/w.thumb.png"));
|
||||
|
||||
// Legacy API fields
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"part__name": "Old",
|
||||
"part__description": "Old desc",
|
||||
"part__thumbnail": "/media/old.png",
|
||||
});
|
||||
|
||||
expect(item.partName, equals("Old"));
|
||||
expect(item.partDescription, equals("Old desc"));
|
||||
expect(item.partImage, equals("/media/old.png"));
|
||||
expect(item.partThumbnail, equals("/media/old.png"));
|
||||
|
||||
// Image used as thumbnail backup
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"part_detail": {"image": "/media/w.png"},
|
||||
});
|
||||
|
||||
expect(item.partThumbnail, equals("/media/w.png"));
|
||||
|
||||
// No image at all
|
||||
expect(
|
||||
InvenTreeStockItem.fromJson({}).partThumbnail,
|
||||
equals(InvenTreeAPI.staticThumb),
|
||||
);
|
||||
});
|
||||
|
||||
test("Supplier Information", () async {
|
||||
var item = InvenTreeStockItem.fromJson({
|
||||
"supplier_part": 3,
|
||||
"supplier_part_detail": {
|
||||
"SKU": "SKU-1",
|
||||
"supplier_detail": {"image": "/media/s1.png"},
|
||||
},
|
||||
"supplier_detail": {"supplier_name": "ACME"},
|
||||
});
|
||||
|
||||
expect(item.supplierPartId, equals(3));
|
||||
expect(item.supplierSKU, equals("SKU-1"));
|
||||
expect(item.supplierImage, equals("/media/s1.png"));
|
||||
expect(item.supplierName, equals("ACME"));
|
||||
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"supplier_detail": {"image": "/media/s2.png"},
|
||||
});
|
||||
|
||||
expect(item.supplierImage, equals("/media/s2.png"));
|
||||
expect(InvenTreeStockItem.fromJson({}).supplierImage, equals(""));
|
||||
});
|
||||
|
||||
test("Location", () async {
|
||||
var item = InvenTreeStockItem.fromJson({});
|
||||
|
||||
expect(item.locationName, equals("Unknown Location"));
|
||||
expect(item.locationPathString, equals(L10().locationNotSet));
|
||||
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"location": 7,
|
||||
"location_detail": {"name": "Shelf", "pathstring": "Store/Shelf"},
|
||||
});
|
||||
|
||||
expect(item.locationId, equals(7));
|
||||
expect(item.locationName, equals("Shelf"));
|
||||
expect(item.locationPathString, equals("Store/Shelf"));
|
||||
|
||||
// Legacy name, and no pathstring
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"location": 7,
|
||||
"location_detail": {},
|
||||
"location__name": "Bin",
|
||||
});
|
||||
|
||||
expect(item.locationName, equals("Bin"));
|
||||
expect(item.locationPathString, equals("Bin"));
|
||||
});
|
||||
|
||||
test("Purchase Price", () async {
|
||||
var item = InvenTreeStockItem.fromJson({});
|
||||
|
||||
expect(item.purchasePrice, isNull);
|
||||
expect(item.hasPurchasePrice, isFalse);
|
||||
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"purchase_price": "2.50",
|
||||
"purchase_price_currency": "AUD",
|
||||
});
|
||||
|
||||
expect(item.purchasePrice, equals(2.5));
|
||||
expect(item.hasPurchasePrice, isTrue);
|
||||
expect(item.purchasePriceCurrency, equals("AUD"));
|
||||
|
||||
item = InvenTreeStockItem.fromJson({"purchase_price": "0"});
|
||||
expect(item.hasPurchasePrice, isFalse);
|
||||
});
|
||||
|
||||
test("Attributes", () async {
|
||||
var item = InvenTreeStockItem.fromJson({});
|
||||
|
||||
expect(item.isInStock, isTrue);
|
||||
expect(item.hasSalesOrder, isFalse);
|
||||
expect(item.hasCustomer, isFalse);
|
||||
|
||||
item = InvenTreeStockItem.fromJson({
|
||||
"in_stock": false,
|
||||
"sales_order": 4,
|
||||
"customer": 2,
|
||||
"stale": true,
|
||||
"expired": false,
|
||||
"expiry_date": "2025-01-31",
|
||||
"batch": "B1",
|
||||
"packaging": "Reel",
|
||||
});
|
||||
|
||||
expect(item.isInStock, isFalse);
|
||||
expect(item.hasSalesOrder, isTrue);
|
||||
expect(item.hasCustomer, isTrue);
|
||||
expect(item.stale, isTrue);
|
||||
expect(item.expired, isFalse);
|
||||
expect(item.expiryDateString, equals("2025-01-31"));
|
||||
expect(item.batch, equals("B1"));
|
||||
expect(item.packaging, equals("Reel"));
|
||||
});
|
||||
});
|
||||
|
||||
group("Orders:", () {
|
||||
test("Order", () async {
|
||||
var order = InvenTreeOrder.fromJson({});
|
||||
|
||||
expect(order.lineItemCount, equals(0));
|
||||
expect(order.complete, isTrue);
|
||||
expect(order.totalPrice, isNull);
|
||||
expect(order.totalPriceCurrency, equals(""));
|
||||
expect(order.hasProjectCode, isFalse);
|
||||
|
||||
order = InvenTreeOrder.fromJson({
|
||||
"reference": "PO-0001",
|
||||
"line_items": 5,
|
||||
"completed_lines": 2,
|
||||
"total_price": "100.5",
|
||||
"order_currency": "AUD",
|
||||
"total_price_currency": "USD",
|
||||
"target_date": "2025-06-01",
|
||||
"project_code_detail": {"code": "PRJ", "description": "Project"},
|
||||
"responsible_detail": {"name": "team", "label": "Team"},
|
||||
});
|
||||
|
||||
expect(order.reference, equals("PO-0001"));
|
||||
expect(order.complete, isFalse);
|
||||
expect(order.totalPrice, equals(100.5));
|
||||
expect(order.totalPriceCurrency, equals("AUD"));
|
||||
expect(order.targetDate, equals("2025-06-01"));
|
||||
expect(order.hasProjectCode, isTrue);
|
||||
expect(order.projectCodeDescription, equals("Project"));
|
||||
expect(order.responsibleName, equals("team"));
|
||||
expect(order.responsibleLabel, equals("Team"));
|
||||
|
||||
// Legacy currency field
|
||||
order = InvenTreeOrder.fromJson({"total_price_currency": "USD"});
|
||||
expect(order.totalPriceCurrency, equals("USD"));
|
||||
});
|
||||
|
||||
test("Order Line", () async {
|
||||
var line = InvenTreeOrderLine.fromJson({"quantity": 3});
|
||||
|
||||
expect(line.quantity, equals(3));
|
||||
expect(line.part, isNull);
|
||||
expect(line.partImage, equals(""));
|
||||
|
||||
line = InvenTreeOrderLine.fromJson({
|
||||
"part_detail": {
|
||||
"pk": 4,
|
||||
"name": "Widget",
|
||||
"description": "A widget",
|
||||
"image": "/media/w.png",
|
||||
},
|
||||
});
|
||||
|
||||
expect(line.part?.name, equals("Widget"));
|
||||
expect(line.partId, equals(4));
|
||||
expect(line.partName, equals("Widget"));
|
||||
expect(line.partDescription, equals("A widget"));
|
||||
expect(line.partImage, equals("/media/w.png"));
|
||||
});
|
||||
|
||||
test("Extra Line", () async {
|
||||
final line = InvenTreeExtraLineItem.fromJson({
|
||||
"order": 2,
|
||||
"quantity": "1.5",
|
||||
"price": "10",
|
||||
"price_currency": "EUR",
|
||||
});
|
||||
|
||||
expect(line.orderId, equals(2));
|
||||
expect(line.quantity, equals(1.5));
|
||||
expect(line.price, equals(10));
|
||||
expect(line.priceCurrency, equals("EUR"));
|
||||
expect(line.formFields()["order"]?["hidden"], isTrue);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,578 @@
|
||||
/*
|
||||
* Unit tests for order and company model classes constructed from JSON data
|
||||
*
|
||||
* Status code data is provided directly, rather than loaded from the server
|
||||
*/
|
||||
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/api.dart";
|
||||
import "package:inventree/inventree/build.dart";
|
||||
import "package:inventree/inventree/company.dart";
|
||||
import "package:inventree/inventree/purchase_order.dart";
|
||||
import "package:inventree/inventree/sales_order.dart";
|
||||
import "package:inventree/inventree/transfer_order.dart";
|
||||
import "package:inventree/l10.dart";
|
||||
|
||||
// Construct status code data in the format provided by the server
|
||||
Map<String, dynamic> statusData(Map<String, int> codes) {
|
||||
return codes.map(
|
||||
(name, key) =>
|
||||
MapEntry(name, {"key": key, "name": name, "label": name.toLowerCase()}),
|
||||
);
|
||||
}
|
||||
|
||||
void main() {
|
||||
setUp(() {
|
||||
InvenTreeAPI().BuildOrderStatus.data = statusData({
|
||||
"PENDING": 10,
|
||||
"PRODUCTION": 20,
|
||||
"CANCELLED": 30,
|
||||
"COMPLETE": 40,
|
||||
"ON_HOLD": 25,
|
||||
});
|
||||
|
||||
InvenTreeAPI().PurchaseOrderStatus.data = statusData({
|
||||
"PENDING": 10,
|
||||
"PLACED": 20,
|
||||
"ON_HOLD": 25,
|
||||
"COMPLETE": 30,
|
||||
"CANCELLED": 40,
|
||||
"LOST": 50,
|
||||
"RETURNED": 60,
|
||||
});
|
||||
|
||||
InvenTreeAPI().SalesOrderStatus.data = statusData({
|
||||
"PENDING": 10,
|
||||
"IN_PROGRESS": 15,
|
||||
"SHIPPED": 20,
|
||||
"ON_HOLD": 25,
|
||||
"COMPLETE": 30,
|
||||
"CANCELLED": 40,
|
||||
});
|
||||
});
|
||||
|
||||
tearDown(() {
|
||||
InvenTreeAPI().clearStatusCodeData();
|
||||
InvenTreeAPI().serverInfo = {};
|
||||
});
|
||||
|
||||
group("Build Order:", () {
|
||||
test("Quantities", () async {
|
||||
var build = InvenTreeBuildOrder.fromJson({
|
||||
"quantity": 10,
|
||||
"completed": 4,
|
||||
"item_count": 3,
|
||||
"allocated_line_count": 3,
|
||||
"output_count": 2,
|
||||
});
|
||||
|
||||
expect(build.progressPercent, equals(40));
|
||||
expect(build.remaining, equals(6));
|
||||
expect(build.lineItemCount, equals(3));
|
||||
expect(build.areAllLinesAllocated, isTrue);
|
||||
expect(build.outputCount, equals(2));
|
||||
|
||||
// Progress is clamped
|
||||
build = InvenTreeBuildOrder.fromJson({"quantity": 10, "completed": 15});
|
||||
expect(build.progressPercent, equals(100));
|
||||
|
||||
build = InvenTreeBuildOrder.fromJson({"quantity": 0, "completed": 1});
|
||||
expect(build.progressPercent, equals(0));
|
||||
|
||||
// No line items
|
||||
expect(InvenTreeBuildOrder.fromJson({}).areAllLinesAllocated, isFalse);
|
||||
});
|
||||
|
||||
test("Details", () async {
|
||||
var build = InvenTreeBuildOrder.fromJson({
|
||||
"parent": 3,
|
||||
"part_detail": {"name": "Assembly"},
|
||||
"destination_detail": {"name": "Store"},
|
||||
});
|
||||
|
||||
expect(build.isParentBuild, isTrue);
|
||||
expect(build.parentBuildId, equals(3));
|
||||
expect(build.partDetail?.name, equals("Assembly"));
|
||||
expect(build.destinationName, equals("Store"));
|
||||
|
||||
build = InvenTreeBuildOrder.fromJson({});
|
||||
expect(build.isParentBuild, isFalse);
|
||||
expect(build.partDetail, isNull);
|
||||
});
|
||||
|
||||
test("Status", () async {
|
||||
InvenTreeBuildOrder build(int status) =>
|
||||
InvenTreeBuildOrder.fromJson({"status": status, "output_count": 1});
|
||||
|
||||
final pending = build(10);
|
||||
expect(pending.isWaitingForBuild, isTrue);
|
||||
expect(pending.canIssue, isTrue);
|
||||
expect(pending.canHold, isTrue);
|
||||
expect(pending.canCancel, isTrue);
|
||||
expect(pending.canCompleteOrder, isFalse);
|
||||
|
||||
final production = build(20);
|
||||
expect(production.isInProgress, isTrue);
|
||||
expect(production.canIssue, isFalse);
|
||||
expect(production.canHold, isTrue);
|
||||
expect(production.canCompleteOrder, isTrue);
|
||||
|
||||
// Cannot complete without any outputs
|
||||
expect(
|
||||
InvenTreeBuildOrder.fromJson({"status": 20}).canCompleteOrder,
|
||||
isFalse,
|
||||
);
|
||||
|
||||
final onHold = build(25);
|
||||
expect(onHold.isOnHold, isTrue);
|
||||
expect(onHold.canIssue, isTrue);
|
||||
expect(onHold.canHold, isFalse);
|
||||
|
||||
final complete = build(40);
|
||||
expect(complete.isComplete, isTrue);
|
||||
expect(complete.canCancel, isFalse);
|
||||
|
||||
final cancelled = build(30);
|
||||
expect(cancelled.isCancelled, isTrue);
|
||||
expect(cancelled.canCancel, isFalse);
|
||||
expect(cancelled.canIssue, isFalse);
|
||||
});
|
||||
|
||||
test("Build Line", () async {
|
||||
var line = InvenTreeBuildLine.fromJson({
|
||||
"quantity": 10,
|
||||
"allocated": 5,
|
||||
"bom_item_detail": {"reference": "R1"},
|
||||
});
|
||||
|
||||
expect(line.isFullyAllocated, isFalse);
|
||||
expect(line.isOverallocated, isFalse);
|
||||
expect(line.progressPercent, equals(50));
|
||||
expect(line.bomReference, equals("R1"));
|
||||
|
||||
// Allow for floating point error
|
||||
line = InvenTreeBuildLine.fromJson({
|
||||
"quantity": 0.3,
|
||||
"allocated": 0.1 + 0.2 - 0.00001,
|
||||
});
|
||||
expect(line.isFullyAllocated, isTrue);
|
||||
|
||||
line = InvenTreeBuildLine.fromJson({"quantity": 2, "allocated": 3});
|
||||
expect(line.isOverallocated, isTrue);
|
||||
expect(line.progressPercent, equals(100));
|
||||
|
||||
line = InvenTreeBuildLine.fromJson({"quantity": 0});
|
||||
expect(line.progressPercent, equals(0));
|
||||
});
|
||||
|
||||
test("Build Item", () async {
|
||||
var item = InvenTreeBuildItem.fromJson({
|
||||
"quantity": 2,
|
||||
"stock_item_detail": {"quantity": 5, "serial": ""},
|
||||
"part_detail": {"name": "Resistor"},
|
||||
});
|
||||
|
||||
expect(item.quantity, equals(2));
|
||||
expect(item.stockItem?.quantity, equals(5));
|
||||
expect(item.partName, equals("Resistor"));
|
||||
|
||||
expect(InvenTreeBuildItem.fromJson({}).stockItem, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group("Purchase Order:", () {
|
||||
test("Status", () async {
|
||||
InvenTreePurchaseOrder order(int status) =>
|
||||
InvenTreePurchaseOrder.fromJson({"status": status});
|
||||
|
||||
expect(order(10).isOpen, isTrue);
|
||||
expect(order(10).isPending, isTrue);
|
||||
expect(order(10).isPlaced, isFalse);
|
||||
|
||||
expect(order(20).isOpen, isTrue);
|
||||
expect(order(20).isPlaced, isTrue);
|
||||
expect(order(20).isPending, isFalse);
|
||||
|
||||
expect(order(25).isPending, isTrue);
|
||||
|
||||
expect(order(30).isOpen, isFalse);
|
||||
expect(order(30).isFailed, isFalse);
|
||||
|
||||
for (final status in [40, 50, 60]) {
|
||||
expect(order(status).isFailed, isTrue);
|
||||
expect(order(status).isOpen, isFalse);
|
||||
}
|
||||
});
|
||||
|
||||
test("Supplier", () async {
|
||||
var order = InvenTreePurchaseOrder.fromJson({
|
||||
"supplier": 2,
|
||||
"supplier_detail": {"name": "ACME"},
|
||||
"supplier_reference": "REF-1",
|
||||
});
|
||||
|
||||
expect(order.supplierId, equals(2));
|
||||
expect(order.supplier?.name, equals("ACME"));
|
||||
expect(order.supplierReference, equals("REF-1"));
|
||||
|
||||
expect(InvenTreePurchaseOrder.fromJson({}).supplier, isNull);
|
||||
});
|
||||
|
||||
test("Line Item", () async {
|
||||
var line = InvenTreePOLineItem.fromJson({
|
||||
"quantity": 8,
|
||||
"received": 2,
|
||||
"purchase_price": "1.5",
|
||||
"supplier_part_detail": {"SKU": "SKU-1"},
|
||||
"order_detail": {"reference": "PO-1"},
|
||||
});
|
||||
|
||||
expect(line.isComplete, isFalse);
|
||||
expect(line.progressRatio, equals(0.25));
|
||||
expect(line.progressString, equals("2 / 8"));
|
||||
expect(line.outstanding, equals(6));
|
||||
expect(line.SKU, equals("SKU-1"));
|
||||
expect(line.purchasePrice, equals(1.5));
|
||||
expect(line.supplierPart?.SKU, equals("SKU-1"));
|
||||
expect(line.purchaseOrder?.reference, equals("PO-1"));
|
||||
|
||||
line = InvenTreePOLineItem.fromJson({"quantity": 8, "received": 8});
|
||||
expect(line.isComplete, isTrue);
|
||||
expect(line.supplierPart, isNull);
|
||||
expect(line.purchaseOrder, isNull);
|
||||
|
||||
line = InvenTreePOLineItem.fromJson({"quantity": 0});
|
||||
expect(line.progressRatio, equals(0));
|
||||
});
|
||||
});
|
||||
|
||||
group("Sales Order:", () {
|
||||
test("Status", () async {
|
||||
InvenTreeSalesOrder order(int status) =>
|
||||
InvenTreeSalesOrder.fromJson({"status": status});
|
||||
|
||||
expect(order(10).isOpen, isTrue);
|
||||
expect(order(10).isPending, isTrue);
|
||||
|
||||
expect(order(15).isOpen, isTrue);
|
||||
expect(order(15).isInProgress, isTrue);
|
||||
expect(order(15).isPending, isFalse);
|
||||
|
||||
expect(order(25).isPending, isTrue);
|
||||
|
||||
expect(order(20).isComplete, isTrue);
|
||||
expect(order(20).isOpen, isFalse);
|
||||
|
||||
expect(order(40).isOpen, isFalse);
|
||||
});
|
||||
|
||||
test("Customer", () async {
|
||||
var order = InvenTreeSalesOrder.fromJson({
|
||||
"customer": 4,
|
||||
"customer_detail": {"name": "Customer"},
|
||||
"customer_reference": "CUST-1",
|
||||
});
|
||||
|
||||
expect(order.customerId, equals(4));
|
||||
expect(order.customer?.name, equals("Customer"));
|
||||
expect(order.customerReference, equals("CUST-1"));
|
||||
|
||||
expect(InvenTreeSalesOrder.fromJson({}).customer, isNull);
|
||||
});
|
||||
|
||||
test("Line Item", () async {
|
||||
var line = InvenTreeSOLineItem.fromJson({
|
||||
"quantity": 10,
|
||||
"allocated": 4,
|
||||
"shipped": 5,
|
||||
"available_stock": 7,
|
||||
"available_variant_stock": 3,
|
||||
});
|
||||
|
||||
expect(line.isAllocated, isFalse);
|
||||
expect(line.allocatedRatio, equals(0.4));
|
||||
expect(line.unallocatedQuantity, equals(6));
|
||||
expect(line.allocatedString, equals("4 / 10"));
|
||||
expect(line.progressRatio, equals(0.5));
|
||||
expect(line.progressString, equals("5 / 10"));
|
||||
expect(line.outstanding, equals(5));
|
||||
expect(line.isComplete, isFalse);
|
||||
expect(line.availableStock, equals(7));
|
||||
expect(line.available, equals(10));
|
||||
|
||||
// Overallocated
|
||||
line = InvenTreeSOLineItem.fromJson({
|
||||
"quantity": 2,
|
||||
"allocated": 5,
|
||||
"shipped": 2,
|
||||
});
|
||||
|
||||
expect(line.isAllocated, isTrue);
|
||||
expect(line.unallocatedQuantity, equals(0));
|
||||
expect(line.isComplete, isTrue);
|
||||
|
||||
line = InvenTreeSOLineItem.fromJson({"quantity": 0});
|
||||
expect(line.allocatedRatio, equals(0));
|
||||
expect(line.progressRatio, equals(0));
|
||||
|
||||
expect(
|
||||
line.allocateFormFields()["stock_item"]?["parent"],
|
||||
equals("items"),
|
||||
);
|
||||
});
|
||||
|
||||
test("Shipment", () async {
|
||||
var shipment = InvenTreeSalesOrderShipment.fromJson({
|
||||
"pk": 3,
|
||||
"reference": "SHIP-1",
|
||||
"checked_by": 1,
|
||||
"shipment_date": "2025-01-01",
|
||||
"delivery_date": "",
|
||||
"order_detail": {"reference": "SO-1"},
|
||||
});
|
||||
|
||||
expect(shipment.SHIP_SHIPMENT_URL, equals("order/so/shipment/3/ship/"));
|
||||
expect(shipment.reference, equals("SHIP-1"));
|
||||
expect(shipment.isChecked, isTrue);
|
||||
expect(shipment.isShipped, isTrue);
|
||||
expect(shipment.isDelivered, isFalse);
|
||||
expect(shipment.order?.reference, equals("SO-1"));
|
||||
|
||||
shipment = InvenTreeSalesOrderShipment.fromJson({});
|
||||
expect(shipment.isChecked, isFalse);
|
||||
expect(shipment.isShipped, isFalse);
|
||||
expect(shipment.order, isNull);
|
||||
});
|
||||
|
||||
test("Allocation", () async {
|
||||
var allocation = InvenTreeSalesOrderAllocation.fromJson({
|
||||
"shipment": 2,
|
||||
"order_detail": {"reference": "SO-1"},
|
||||
"item_detail": {"serial": "123"},
|
||||
"part_detail": {"name": "Widget"},
|
||||
"shipment_detail": {"reference": "SHIP-1"},
|
||||
"location_detail": {"name": "Shelf"},
|
||||
});
|
||||
|
||||
expect(allocation.hasShipment, isTrue);
|
||||
expect(allocation.order?.reference, equals("SO-1"));
|
||||
expect(allocation.stockItem?.serialNumber, equals("123"));
|
||||
expect(allocation.part?.name, equals("Widget"));
|
||||
expect(allocation.shipment?.reference, equals("SHIP-1"));
|
||||
expect(allocation.location?.name, equals("Shelf"));
|
||||
|
||||
allocation = InvenTreeSalesOrderAllocation.fromJson({});
|
||||
expect(allocation.hasShipment, isFalse);
|
||||
expect(allocation.order, isNull);
|
||||
expect(allocation.stockItem, isNull);
|
||||
expect(allocation.part, isNull);
|
||||
expect(allocation.shipment, isNull);
|
||||
expect(allocation.location, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group("Transfer Order:", () {
|
||||
test("Status Codes", () async {
|
||||
expect(TransferOrderStatus.name(10), equals("PENDING"));
|
||||
expect(TransferOrderStatus.name(99), equals(""));
|
||||
expect(TransferOrderStatus.isNameIn(30, ["COMPLETE"]), isTrue);
|
||||
expect(TransferOrderStatus.isNameIn(99, ["COMPLETE"]), isFalse);
|
||||
|
||||
expect(TransferOrderStatus.getStatusText(10), equals(L10().pending));
|
||||
expect(TransferOrderStatus.getStatusText(20), equals(L10().issued));
|
||||
expect(TransferOrderStatus.getStatusText(25), equals(L10().onHold));
|
||||
expect(TransferOrderStatus.getStatusText(30), equals(L10().complete));
|
||||
expect(TransferOrderStatus.getStatusText(40), equals(L10().cancelled));
|
||||
expect(TransferOrderStatus.getStatusText(99), equals(L10().unknown));
|
||||
});
|
||||
|
||||
test("Status", () async {
|
||||
InvenTreeTransferOrder order(int status) =>
|
||||
InvenTreeTransferOrder.fromJson({"status": status});
|
||||
|
||||
final pending = order(TransferOrderStatus.PENDING);
|
||||
expect(pending.isOpen, isTrue);
|
||||
expect(pending.canIssue, isTrue);
|
||||
expect(pending.canHold, isTrue);
|
||||
expect(pending.canCompleteOrder, isFalse);
|
||||
expect(pending.canCancel, isTrue);
|
||||
|
||||
final issued = order(TransferOrderStatus.ISSUED);
|
||||
expect(issued.canIssue, isFalse);
|
||||
expect(issued.canHold, isTrue);
|
||||
expect(issued.canCompleteOrder, isTrue);
|
||||
|
||||
final onHold = order(TransferOrderStatus.ON_HOLD);
|
||||
expect(onHold.canIssue, isTrue);
|
||||
expect(onHold.canHold, isFalse);
|
||||
expect(onHold.canCompleteOrder, isTrue);
|
||||
|
||||
for (final status in [
|
||||
TransferOrderStatus.COMPLETE,
|
||||
TransferOrderStatus.CANCELLED,
|
||||
]) {
|
||||
expect(order(status).isOpen, isFalse);
|
||||
expect(order(status).canCancel, isFalse);
|
||||
expect(order(status).canCompleteOrder, isFalse);
|
||||
}
|
||||
});
|
||||
|
||||
test("Locations", () async {
|
||||
var order = InvenTreeTransferOrder.fromJson({
|
||||
"take_from": 2,
|
||||
"destination": 3,
|
||||
"consume": true,
|
||||
});
|
||||
|
||||
expect(order.sourceLocationId, equals(2));
|
||||
expect(order.destinationId, equals(3));
|
||||
expect(order.consume, isTrue);
|
||||
|
||||
order = InvenTreeTransferOrder.fromJson({"take_from": null});
|
||||
expect(order.sourceLocationId, isNull);
|
||||
expect(order.destinationId, isNull);
|
||||
});
|
||||
|
||||
test("Line Item", () async {
|
||||
var line = InvenTreeTransferOrderLineItem.fromJson({
|
||||
"quantity": 4,
|
||||
"allocated": 4,
|
||||
"transferred": 1,
|
||||
"order_detail": {"reference": "TO-1"},
|
||||
});
|
||||
|
||||
expect(line.isComplete, isFalse);
|
||||
expect(line.outstanding, equals(3));
|
||||
expect(line.progressRatio, equals(0.25));
|
||||
expect(line.progressString, equals("1 / 4"));
|
||||
expect(line.transferOrder?.reference, equals("TO-1"));
|
||||
|
||||
line = InvenTreeTransferOrderLineItem.fromJson({"quantity": 0});
|
||||
expect(line.isComplete, isTrue);
|
||||
expect(line.progressRatio, equals(0));
|
||||
expect(line.transferOrder, isNull);
|
||||
});
|
||||
|
||||
test("Allocation", () async {
|
||||
var allocation = InvenTreeTransferOrderAllocation.fromJson({
|
||||
"quantity": 2,
|
||||
"order_detail": {"reference": "TO-1"},
|
||||
"item_detail": {"serial": "123"},
|
||||
"part_detail": {"name": "Widget"},
|
||||
"location_detail": {"name": "Shelf"},
|
||||
});
|
||||
|
||||
expect(allocation.quantity, equals(2));
|
||||
expect(allocation.order?.reference, equals("TO-1"));
|
||||
expect(allocation.stockItem?.serialNumber, equals("123"));
|
||||
expect(allocation.part?.name, equals("Widget"));
|
||||
expect(allocation.location?.name, equals("Shelf"));
|
||||
|
||||
allocation = InvenTreeTransferOrderAllocation.fromJson({});
|
||||
expect(allocation.order, isNull);
|
||||
expect(allocation.stockItem, isNull);
|
||||
expect(allocation.part, isNull);
|
||||
expect(allocation.location, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group("Company:", () {
|
||||
test("Company", () async {
|
||||
var company = InvenTreeCompany.fromJson({});
|
||||
|
||||
expect(company.image, equals(InvenTreeAPI.staticImage));
|
||||
expect(company.thumbnail, equals(InvenTreeAPI.staticThumb));
|
||||
expect(company.active, isTrue);
|
||||
expect(company.isSupplier, isFalse);
|
||||
|
||||
company = InvenTreeCompany.fromJson({
|
||||
"image": "/media/c.png",
|
||||
"is_supplier": true,
|
||||
"is_customer": true,
|
||||
"active": false,
|
||||
});
|
||||
|
||||
expect(company.image, equals("/media/c.png"));
|
||||
expect(company.thumbnail, equals("/media/c.png"));
|
||||
expect(company.isSupplier, isTrue);
|
||||
expect(company.isCustomer, isTrue);
|
||||
expect(company.isManufacturer, isFalse);
|
||||
expect(company.active, isFalse);
|
||||
|
||||
company = InvenTreeCompany.fromJson({"thumbnail": "/media/c.thumb.png"});
|
||||
expect(company.image, equals("/media/c.thumb.png"));
|
||||
});
|
||||
|
||||
test("Company Form Fields", () async {
|
||||
expect(InvenTreeCompany().formFields().containsKey("active"), isFalse);
|
||||
|
||||
InvenTreeAPI().serverInfo = {"apiVersion": 189};
|
||||
expect(InvenTreeCompany().formFields().containsKey("active"), isTrue);
|
||||
});
|
||||
|
||||
test("Supplier Part", () async {
|
||||
var sp = InvenTreeSupplierPart.fromJson({
|
||||
"SKU": "SKU-1",
|
||||
"pack_size": "10",
|
||||
"pack_quantity": "1 reel",
|
||||
"manufacturer_detail": {"pk": 5, "name": "MFG", "thumbnail": "/m.png"},
|
||||
"supplier_detail": {"name": "ACME", "image": "/s.png"},
|
||||
"manufacturer_part_detail": {"MPN": "MPN-1"},
|
||||
"part_detail": {"name": "Widget", "thumbnail": "/p.png"},
|
||||
});
|
||||
|
||||
expect(sp.SKU, equals("SKU-1"));
|
||||
expect(sp.manufacturerId, equals(5));
|
||||
expect(sp.manufacturerName, equals("MFG"));
|
||||
expect(sp.manufacturerImage, equals("/m.png"));
|
||||
expect(sp.supplierName, equals("ACME"));
|
||||
expect(sp.supplierImage, equals("/s.png"));
|
||||
expect(sp.MPN, equals("MPN-1"));
|
||||
expect(sp.partName, equals("Widget"));
|
||||
expect(sp.partImage, equals("/p.png"));
|
||||
expect(sp.active, isTrue);
|
||||
expect(sp.primary, isFalse);
|
||||
|
||||
// Older API versions use "pack_size"
|
||||
expect(sp.pack_quantity, equals("10"));
|
||||
expect(sp.formFields().containsKey("pack_size"), isTrue);
|
||||
expect(sp.formFields().containsKey("primary"), isFalse);
|
||||
|
||||
InvenTreeAPI().serverInfo = {"apiVersion": 456};
|
||||
expect(sp.pack_quantity, equals("1 reel"));
|
||||
expect(sp.formFields().containsKey("pack_quantity"), isTrue);
|
||||
expect(sp.formFields().containsKey("primary"), isTrue);
|
||||
|
||||
// Missing images
|
||||
sp = InvenTreeSupplierPart.fromJson({});
|
||||
expect(sp.manufacturerImage, equals(InvenTreeAPI.staticThumb));
|
||||
expect(sp.supplierImage, equals(InvenTreeAPI.staticThumb));
|
||||
expect(sp.partImage, equals(InvenTreeAPI.staticThumb));
|
||||
});
|
||||
|
||||
test("Manufacturer Part", () async {
|
||||
var mp = InvenTreeManufacturerPart.fromJson({
|
||||
"MPN": "MPN-1",
|
||||
"manufacturer": 5,
|
||||
"manufacturer_detail": {
|
||||
"name": "MFG",
|
||||
"description": "Manufacturer",
|
||||
"image": "/m.png",
|
||||
},
|
||||
"part_detail": {"name": "Widget", "IPN": "W-1"},
|
||||
});
|
||||
|
||||
expect(mp.MPN, equals("MPN-1"));
|
||||
expect(mp.manufacturerId, equals(5));
|
||||
expect(mp.manufacturerName, equals("MFG"));
|
||||
expect(mp.manufacturerDescription, equals("Manufacturer"));
|
||||
expect(mp.manufacturerImage, equals("/m.png"));
|
||||
expect(mp.partName, equals("Widget"));
|
||||
expect(mp.partIPN, equals("W-1"));
|
||||
expect(mp.partImage, equals(InvenTreeAPI.staticThumb));
|
||||
|
||||
mp = InvenTreeManufacturerPart.fromJson({});
|
||||
expect(mp.manufacturerImage, equals(InvenTreeAPI.staticThumb));
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
* Unit tests for the InvenTreeStatusCode class
|
||||
*
|
||||
* Status code data is provided directly, rather than loaded from the server
|
||||
*/
|
||||
|
||||
import "package:flutter/material.dart";
|
||||
import "package:flutter_test/flutter_test.dart";
|
||||
import "package:inventree/app_colors.dart";
|
||||
import "package:inventree/inventree/status_codes.dart";
|
||||
import "package:one_context/one_context.dart";
|
||||
|
||||
InvenTreeStatusCode buildStatusCodes() {
|
||||
final codes = InvenTreeStatusCode("stock/status/");
|
||||
|
||||
codes.data = {
|
||||
"OK": {"key": 10, "name": "OK", "label": "OK", "color": "success"},
|
||||
"ATTENTION": {
|
||||
"key": 50,
|
||||
"name": "ATTENTION",
|
||||
"label": "Attention needed",
|
||||
"color": "WARNING",
|
||||
},
|
||||
"DAMAGED": {"key": 55, "name": "DAMAGED", "label": "Damaged"},
|
||||
"DESTROYED": {
|
||||
"key": 60,
|
||||
"name": "DESTROYED",
|
||||
"label": "Destroyed",
|
||||
"color": "danger",
|
||||
},
|
||||
// Malformed entries should be ignored
|
||||
"INVALID": "not a map",
|
||||
"STRING_KEY": {"key": "70", "name": "STRING_KEY", "label": "String"},
|
||||
};
|
||||
|
||||
return codes;
|
||||
}
|
||||
|
||||
void main() {
|
||||
group("Status Codes:", () {
|
||||
test("Choices", () async {
|
||||
final codes = buildStatusCodes();
|
||||
|
||||
expect(
|
||||
codes.choices,
|
||||
equals([
|
||||
{"value": 10, "display_name": "OK"},
|
||||
{"value": 50, "display_name": "Attention needed"},
|
||||
{"value": 55, "display_name": "Damaged"},
|
||||
{"value": 60, "display_name": "Destroyed"},
|
||||
{"value": "70", "display_name": "String"},
|
||||
]),
|
||||
);
|
||||
|
||||
expect(InvenTreeStatusCode("x/").choices, isEmpty);
|
||||
});
|
||||
|
||||
test("Entry", () async {
|
||||
final codes = buildStatusCodes();
|
||||
|
||||
expect(codes.entry(50)["name"], equals("ATTENTION"));
|
||||
expect(codes.entry(999), isEmpty);
|
||||
|
||||
// Only integer keys are matched
|
||||
expect(codes.entry(70), isEmpty);
|
||||
});
|
||||
|
||||
test("Label", () async {
|
||||
final codes = buildStatusCodes();
|
||||
|
||||
expect(codes.label(10), equals("OK"));
|
||||
expect(codes.label(50), equals("Attention needed"));
|
||||
|
||||
// Unknown status returns the code itself
|
||||
expect(codes.label(999), equals("999"));
|
||||
});
|
||||
|
||||
test("Name", () async {
|
||||
final codes = buildStatusCodes();
|
||||
|
||||
expect(codes.name(60), equals("DESTROYED"));
|
||||
expect(codes.name(999), equals(""));
|
||||
|
||||
expect(codes.isNameIn(10, ["OK", "DAMAGED"]), isTrue);
|
||||
expect(codes.isNameIn(60, ["OK", "DAMAGED"]), isFalse);
|
||||
expect(codes.isNameIn(999, ["OK"]), isFalse);
|
||||
});
|
||||
|
||||
// Theme-dependent colors require an app context
|
||||
testWidgets("Color", (tester) async {
|
||||
OneContext().key = GlobalKey<NavigatorState>();
|
||||
|
||||
await tester.pumpWidget(
|
||||
MaterialApp(
|
||||
builder: OneContext().builder,
|
||||
navigatorKey: OneContext().key,
|
||||
home: const SizedBox(),
|
||||
),
|
||||
);
|
||||
|
||||
final codes = buildStatusCodes();
|
||||
|
||||
expect(codes.color(10), equals(COLOR_SUCCESS));
|
||||
expect(codes.color(50), equals(COLOR_WARNING));
|
||||
expect(codes.color(60), equals(COLOR_DANGER));
|
||||
|
||||
// Missing color, or unknown status
|
||||
expect(codes.color(55), equals(COLOR_GRAY_LIGHT));
|
||||
expect(codes.color(999), equals(COLOR_GRAY_LIGHT));
|
||||
|
||||
final Map<String, Color> colors = {
|
||||
"primary": COLOR_PROGRESS,
|
||||
"secondary": COLOR_GRAY_LIGHT,
|
||||
"dark": COLOR_TEXT,
|
||||
"info": COLOR_PROGRESS,
|
||||
"unknown": COLOR_GRAY_LIGHT,
|
||||
};
|
||||
|
||||
colors.forEach((name, color) {
|
||||
codes.data = {
|
||||
"X": {"key": 1, "name": "X", "label": "X", "color": name},
|
||||
};
|
||||
|
||||
expect(codes.color(1), equals(color), reason: name);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user