mirror of
https://github.com/inventree/inventree-app.git
synced 2026-11-17 03:14:49 +00:00
847 lines
27 KiB
Dart
847 lines
27 KiB
Dart
/*
|
|
* Unit tests for model classes constructed from JSON data
|
|
*
|
|
* These tests do not require a connection to the server
|
|
*/
|
|
|
|
import "package:flutter/material.dart";
|
|
import "package:flutter_tabler_icons/flutter_tabler_icons.dart";
|
|
import "package:flutter_test/flutter_test.dart";
|
|
import "package:inventree/api.dart";
|
|
import "package:inventree/inventree/attachment.dart";
|
|
import "package:inventree/inventree/bom.dart";
|
|
import "package:inventree/inventree/model.dart";
|
|
import "package:inventree/inventree/notes.dart";
|
|
import "package:inventree/inventree/notification.dart";
|
|
import "package:inventree/inventree/orders.dart";
|
|
import "package:inventree/inventree/parameter.dart";
|
|
import "package:inventree/inventree/part.dart";
|
|
import "package:inventree/inventree/project_code.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);
|
|
});
|
|
});
|
|
|
|
group("Attachment:", () {
|
|
test("Empty Data", () async {
|
|
final attachment = InvenTreeAttachment.fromJson({});
|
|
|
|
expect(attachment.URL, equals("attachment/"));
|
|
expect(attachment.attachment, equals(""));
|
|
expect(attachment.hasAttachment, isFalse);
|
|
expect(attachment.filename, equals(""));
|
|
expect(attachment.icon, equals(TablerIcons.file));
|
|
expect(attachment.comment, equals(""));
|
|
expect(attachment.uploadDate, isNull);
|
|
expect(attachment.modelType, equals(""));
|
|
expect(attachment.modelId, equals(-1));
|
|
|
|
// No link, so the 'link' field is not displayed
|
|
expect(attachment.formFields().keys, equals(["comment"]));
|
|
|
|
expect(
|
|
attachment.createFromJson({"pk": 3}),
|
|
isA<InvenTreeAttachment>().having((a) => a.pk, "pk", 3),
|
|
);
|
|
});
|
|
|
|
test("File Attachment", () async {
|
|
final attachment = InvenTreeAttachment.fromJson({
|
|
"attachment": "/media/attachments/part/7/Datasheet.PDF",
|
|
"comment": "A datasheet",
|
|
"upload_date": "2024-03-15",
|
|
"model_type": "part",
|
|
"model_id": 7,
|
|
});
|
|
|
|
expect(attachment.hasAttachment, isTrue);
|
|
expect(attachment.filename, equals("Datasheet.PDF"));
|
|
expect(attachment.icon, equals(TablerIcons.file_type_pdf));
|
|
expect(attachment.comment, equals("A datasheet"));
|
|
expect(attachment.uploadDate, equals(DateTime(2024, 3, 15)));
|
|
expect(attachment.modelType, equals("part"));
|
|
expect(attachment.modelId, equals(7));
|
|
expect(attachment.formFields().keys, equals(["comment"]));
|
|
});
|
|
|
|
test("Link Attachment", () async {
|
|
final attachment = InvenTreeAttachment.fromJson({
|
|
"link": "https://inventree.org",
|
|
"upload_date": null,
|
|
});
|
|
|
|
expect(attachment.hasAttachment, isFalse);
|
|
expect(attachment.formFields().keys, equals(["link", "comment"]));
|
|
|
|
// Null (or invalid) dates are not parsed
|
|
expect(attachment.uploadDate, isNull);
|
|
expect(
|
|
InvenTreeAttachment.fromJson({"upload_date": "junk"}).uploadDate,
|
|
isNull,
|
|
);
|
|
});
|
|
|
|
test("File Icons", () async {
|
|
final Map<String, IconData> icons = {
|
|
"report.pdf": TablerIcons.file_type_pdf,
|
|
"data.csv": TablerIcons.file_type_csv,
|
|
"notes.doc": TablerIcons.file_type_doc,
|
|
"notes.docx": TablerIcons.file_type_doc,
|
|
"sheet.xls": TablerIcons.file_type_xls,
|
|
"sheet.XLSX": TablerIcons.file_type_xls,
|
|
"photo.png": TablerIcons.file_type_jpg,
|
|
"photo.jpg": TablerIcons.file_type_jpg,
|
|
"anim.gif": TablerIcons.file_type_jpg,
|
|
"image.bmp": TablerIcons.file_type_jpg,
|
|
"logo.svg": TablerIcons.file_type_jpg,
|
|
"archive.zip": TablerIcons.file,
|
|
"no_extension": TablerIcons.file,
|
|
};
|
|
|
|
for (final entry in icons.entries) {
|
|
final attachment = InvenTreeAttachment.fromJson({
|
|
"attachment": "/media/attachments/${entry.key}",
|
|
});
|
|
|
|
expect(attachment.icon, equals(entry.value), reason: entry.key);
|
|
}
|
|
});
|
|
});
|
|
|
|
group("Notification:", () {
|
|
test("Accessors", () async {
|
|
final notification = InvenTreeNotification.fromJson({
|
|
"pk": 12,
|
|
"message": "Stock is low",
|
|
"creation": "2024-05-01T10:30:00",
|
|
});
|
|
|
|
expect(notification.URL, equals("notifications/"));
|
|
expect(notification.defaultListFilters(), equals({"read": "false"}));
|
|
expect(notification.message, equals("Stock is low"));
|
|
expect(notification.creationDate, equals(DateTime(2024, 5, 1, 10, 30)));
|
|
|
|
expect(
|
|
notification.createFromJson({"pk": 1}),
|
|
isA<InvenTreeNotification>(),
|
|
);
|
|
});
|
|
|
|
test("Missing Date", () async {
|
|
expect(InvenTreeNotification.fromJson({}).creationDate, isNull);
|
|
expect(
|
|
InvenTreeNotification.fromJson({"creation": null}).creationDate,
|
|
isNull,
|
|
);
|
|
expect(
|
|
InvenTreeNotification.fromJson({"creation": "junk"}).creationDate,
|
|
isNull,
|
|
);
|
|
expect(InvenTreeNotification.fromJson({}).message, equals(""));
|
|
});
|
|
});
|
|
|
|
group("Project Code:", () {
|
|
test("Accessors", () async {
|
|
final code = InvenTreeProjectCode.fromJson({
|
|
"pk": 4,
|
|
"code": "PRJ-001",
|
|
"description": "Test project",
|
|
});
|
|
|
|
expect(InvenTreeProjectCode.MODEL_TYPE, equals("projectcode"));
|
|
expect(code.URL, equals("project-code/"));
|
|
expect(code.code, equals("PRJ-001"));
|
|
expect(code.description, equals("Test project"));
|
|
expect(code.formFields().keys, equals(["code", "description"]));
|
|
expect(InvenTreeProjectCode().code, equals(""));
|
|
|
|
expect(
|
|
code.createFromJson({"pk": 5}),
|
|
isA<InvenTreeProjectCode>().having((c) => c.pk, "pk", 5),
|
|
);
|
|
});
|
|
});
|
|
|
|
group("Parameter:", () {
|
|
test("Accessors", () async {
|
|
final parameter = InvenTreeParameter.fromJson({
|
|
"pk": 9,
|
|
"data": "12",
|
|
"model_type": "part",
|
|
"model_id": 3,
|
|
"template_detail": {
|
|
"name": "Length",
|
|
"description": "Overall length",
|
|
"units": "mm",
|
|
"checkbox": false,
|
|
},
|
|
});
|
|
|
|
expect(parameter.URL, equals("parameter/"));
|
|
expect(parameter.name, equals("Length"));
|
|
expect(parameter.description, equals("Overall length"));
|
|
expect(parameter.value, equals("12"));
|
|
expect(parameter.units, equals("mm"));
|
|
expect(parameter.valueString, equals("12 mm"));
|
|
expect(parameter.is_checkbox, isFalse);
|
|
expect(parameter.as_bool, isFalse);
|
|
expect(parameter.modelType, equals("part"));
|
|
expect(parameter.modelId, equals(3));
|
|
|
|
final fields = parameter.formFields();
|
|
expect(fields.keys, equals(["header", "data", "note"]));
|
|
expect(fields["header"]?["label"], equals("Length"));
|
|
expect(fields["header"]?["help_text"], equals("Overall length"));
|
|
expect(fields["header"]?["read_only"], isTrue);
|
|
});
|
|
|
|
test("Checkbox", () async {
|
|
final parameter = InvenTreeParameter.fromJson({
|
|
"data": "True",
|
|
"template_detail": {"name": "RoHS", "checkbox": true},
|
|
});
|
|
|
|
expect(parameter.is_checkbox, isTrue);
|
|
expect(parameter.as_bool, isTrue);
|
|
|
|
// No units, so the value is displayed alone
|
|
expect(parameter.valueString, equals("True"));
|
|
|
|
// No template detail
|
|
final empty = InvenTreeParameter.fromJson({"data": "x"});
|
|
expect(empty.is_checkbox, isFalse);
|
|
expect(empty.as_bool, isFalse);
|
|
expect(empty.valueString, equals("x"));
|
|
});
|
|
});
|
|
|
|
group("BOM Item:", () {
|
|
test("Accessors", () async {
|
|
final item = InvenTreeBomItem.fromJson({
|
|
"pk": 1,
|
|
"part": 10,
|
|
"sub_part": 20,
|
|
"quantity": "2.5",
|
|
"reference": "R1, R2",
|
|
"part_detail": {"pk": 10, "name": "Assembly"},
|
|
"sub_part_detail": {"pk": 20, "name": "Resistor"},
|
|
});
|
|
|
|
expect(item.URL, equals("bom/"));
|
|
expect(item.defaultFilters()["sub_part_detail"], equals("true"));
|
|
expect(item.partId, equals(10));
|
|
expect(item.subPartId, equals(20));
|
|
expect(item.quantity, equals(2.5));
|
|
expect(item.reference, equals("R1, R2"));
|
|
expect(item.part?.name, equals("Assembly"));
|
|
expect(item.subPart?.name, equals("Resistor"));
|
|
expect(item.createFromJson({"pk": 2}), isA<InvenTreeBomItem>());
|
|
});
|
|
|
|
test("Missing Detail", () async {
|
|
final item = InvenTreeBomItem.fromJson({
|
|
"sub_part_detail": null,
|
|
"part_detail": "invalid",
|
|
});
|
|
|
|
expect(item.part, isNull);
|
|
expect(item.subPart, isNull);
|
|
expect(InvenTreeBomItem.fromJson({}).subPart, isNull);
|
|
expect(InvenTreeBomItem.fromJson({}).subPartId, equals(-1));
|
|
});
|
|
});
|
|
|
|
group("Note Entry:", () {
|
|
test("Accessors", () async {
|
|
final note = InvenTreeNoteEntry.fromJson({
|
|
"pk": 2,
|
|
"title": "Assembly notes",
|
|
"content": "<p>Handle with care</p>",
|
|
"updated": "2024-06-30",
|
|
"model_type": "build",
|
|
"model_id": 8,
|
|
});
|
|
|
|
expect(note.URL, equals("note/"));
|
|
expect(note.title, equals("Assembly notes"));
|
|
expect(note.content, equals("<p>Handle with care</p>"));
|
|
expect(note.updated, equals(DateTime(2024, 6, 30)));
|
|
expect(note.modelType, equals("build"));
|
|
expect(note.modelId, equals(8));
|
|
expect(note.createFromJson({"pk": 3}), isA<InvenTreeNoteEntry>());
|
|
|
|
final empty = InvenTreeNoteEntry.fromJson({});
|
|
expect(empty.content, equals(""));
|
|
expect(empty.updated, isNull);
|
|
});
|
|
});
|
|
}
|