Improved common APIs and testing

deno.json

@@ -10,7 +10,7 @@
   "tasks": {
     "dev": "deno run --watch --env --unstable-kv -A main.ts",
     "run": "deno run --env --unstable-kv -A main.ts",
-    "test": "DATA_DIR=data-test ASN_PREFIX=ASN ASN_NAMESPACE_RANGE=50 deno test --unstable-kv -A",
+    "test": "DATA_DIR=data-test ASN_PREFIX=ASN ASN_NAMESPACE_RANGE=50 ASN_ENABLE_NAMESPACE_EXTANSION=1 deno test --unstable-kv -A",
     "lint": "deno lint",
     "check": "deno check main.ts",
     "version": "deno run --allow-read=. --allow-write=. --allow-run=git jsr:@utility/version"

lib/common/additional-managed-namespaces.test.ts

@@ -2,9 +2,21 @@ import { assertEquals } from "@std/assert";
 import {
   deserializeAdditionalManagedNamespace,
   deserializeAdditionalManagedNamespaces,
+  isValidAdditionalManagedNamespace,
   serializeAdditionalManagedNamespace,
   serializeAdditionalManagedNamespaces,
-} from "./additional-managed-namespaces.ts";
+} from "$common/additional-managed-namespaces.ts";
+import type { Config } from "$common/config.ts";
+
+const TEST_CONFIG: Config = {
+  PORT: 0,
+  ASN_PREFIX: "ASN",
+  ASN_NAMESPACE_RANGE: 3,
+  ASN_ENABLE_NAMESPACE_EXTENSION: false,
+  ADDITIONAL_MANAGED_NAMESPACES: [],
+  ASN_LOOKUP_INCLUDE_PREFIX: false,
+  ASN_BARCODE_TYPE: "",
+};
 
 Deno.test("serializeAdditionalManagedNamespace", () => {
   assertEquals(
@@ -87,3 +99,139 @@ Deno.test("deserializeAdditionalManagedNamespaces", () => {
     [],
   );
 });
+
+Deno.test("isValidAdditionalManagedNamespace", async (t) => {
+  await t.step("Single Digit Namespace", () => {
+    assertEquals(
+      isValidAdditionalManagedNamespace(5, {
+        ...TEST_CONFIG,
+        ADDITIONAL_MANAGED_NAMESPACES: [{
+          namespace: 5,
+          label: "Test namespace",
+        }],
+      }),
+      true,
+      "Registered managed namespace (5) should be valid for range 3",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(6, { ...TEST_CONFIG }),
+      true,
+      "Unregistered managed namespace (6) should be valid for range 3",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(22, { ...TEST_CONFIG }),
+      false,
+      "Unregistered managed namespace (22) should be invalid for range 3 (too many digits)",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(0, { ...TEST_CONFIG }),
+      false,
+      "Unregistered managed namespace (0) should be invalid for range 3 (too small)",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(-1, { ...TEST_CONFIG }),
+      false,
+      "Unregistered managed namespace (-1) should be invalid for range 3 (negative)",
+    );
+  });
+
+  await t.step("Double Digit Namespace", () => {
+    assertEquals(
+      isValidAdditionalManagedNamespace(50, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+        ADDITIONAL_MANAGED_NAMESPACES: [
+          { namespace: 50, label: "Test namespace" },
+        ],
+      }),
+      true,
+      "Registered managed namespace (50) should be valid for range 20",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(63, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+      }),
+      true,
+      "Unregistered managed namespace (63) should be valid for range 20",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(222, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+      }),
+      false,
+      "Unregistered managed namespace (222) should be invalid for range 20 (too many digits)",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(1, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+      }),
+      false,
+      "Unregistered managed namespace (1) should be invalid for range 20 (too few digits)",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(0, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+      }),
+      false,
+      "Unregistered managed namespace (0) should be invalid for range 20 (too small)",
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(-1, {
+        ...TEST_CONFIG,
+        ASN_NAMESPACE_RANGE: 20,
+      }),
+      false,
+      "Unregistered managed namespace (-1) should be invalid for range 20 (negative)",
+    );
+  });
+
+  await t.step(
+    "Generic Namespace Range isn't valid for additional managed namespaces",
+    () => {
+      assertEquals(
+        isValidAdditionalManagedNamespace(18, {
+          ...TEST_CONFIG,
+          ASN_NAMESPACE_RANGE: 20,
+        }),
+        false,
+        "Generic namespace range should not be valid for additional managed namespaces",
+      );
+      assertEquals(
+        isValidAdditionalManagedNamespace(2, {
+          ...TEST_CONFIG,
+          ASN_NAMESPACE_RANGE: 3,
+        }),
+        false,
+        "Generic namespace range should not be valid for additional managed namespaces",
+      );
+    },
+  );
+
+  await t.step("ASN_ENABLE_NAMESPACE_EXTENSION", () => {
+    assertEquals(
+      isValidAdditionalManagedNamespace(9, { ...TEST_CONFIG }),
+      true,
+      'Namespace "9" should be valid for range 3 without extension',
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(9, {
+        ...TEST_CONFIG,
+        ASN_ENABLE_NAMESPACE_EXTENSION: true,
+      }),
+      false,
+      'Namespace "9" should be invalid for range 3 with extension',
+    );
+    assertEquals(
+      isValidAdditionalManagedNamespace(91, {
+        ...TEST_CONFIG,
+        ASN_ENABLE_NAMESPACE_EXTENSION: true,
+      }),
+      true,
+      'Namespace "91" should be valid for range 3 with extension',
+    );
+  });
+});

lib/common/additional-managed-namespaces.ts

@@ -1,4 +1,4 @@
-import { CONFIG } from "$common/mod.ts";
+import { CONFIG, isValidNamespace } from "$common/mod.ts";
 
 /**
  * An additional managed namespace outside of the default range.
@@ -87,18 +87,26 @@ export function deserializeAdditionalManagedNamespaces(
   return matches.map(deserializeAdditionalManagedNamespace);
 }
 
+/**
+ * Checks if a namespace is a valid additional managed namespace according to the configuration.
+ * Note that "valid" does not necessarily mean "managed".
+ * A valid additional managed namespace is any namespace that fulfills the following conditions:
+ * - The namespace is a safe integer, and
+ * - The namespace has a compatible number of digits based on the configuration, and
+ * - The namespace is greater than or equal to the `ASN_NAMESPACE_RANGE` configuration parameter.
+ *
+ * Any managed namespace must be a valid namespace, but not all valid namespaces are managed.
+ *
+ * @param namespace the namespace to check
+ * @returns `true` if the namespace is a valid additional managed namespace, `false` otherwise
+ */
 export function isValidAdditionalManagedNamespace(
   namespace: number,
+  config = CONFIG,
 ): boolean {
-  let sNamespace = namespace.toString();
-
-  if (CONFIG.ASN_ENABLE_NAMESPACE_EXTENSION) {
-    // strip leading 9s
-    sNamespace = sNamespace.replace(/^9+/, "");
+  if (!isValidNamespace(namespace, config)) {
+    return false;
   }
 
-  return (
-    sNamespace.length === CONFIG.ASN_NAMESPACE_RANGE.toString().length &&
-    namespace >= CONFIG.ASN_NAMESPACE_RANGE
-  );
+  return namespace >= config.ASN_NAMESPACE_RANGE;
 }