URN for image info (#78)

* Allow music service to return a URN identifying cover art for an entity

* Fix bug with playlist cover art rending same album multiple times

tests/burn.test.ts

@@ -0,0 +1,114 @@
+import { assertSystem, BUrn, format, formatForURL, parse } from "../src/burn";
+
+type BUrnSpec = {
+  burn: BUrn;
+  asString: string;
+  shorthand: string;
+};
+
+describe("BUrn", () => {
+  describe("format", () => {
+    (
+      [
+        {
+          burn: { system: "internal", resource: "icon:error" },
+          asString: "bnb:internal:icon:error",
+          shorthand: "bnb:i:icon:error",
+        },
+        {
+          burn: {
+            system: "external",
+            resource: "http://example.com/widget.jpg",
+          },
+          asString: "bnb:external:http://example.com/widget.jpg",
+          shorthand: "bnb:e:http://example.com/widget.jpg",
+        },
+        {
+          burn: { system: "subsonic", resource: "art:1234" },
+          asString: "bnb:subsonic:art:1234",
+          shorthand: "bnb:s:art:1234",
+        },
+        {
+          burn: { system: "navidrome", resource: "art:1234" },
+          asString: "bnb:navidrome:art:1234",
+          shorthand: "bnb:n:art:1234",
+        },
+      ] as BUrnSpec[]
+    ).forEach(({ burn, asString, shorthand }) => {
+      describe(asString, () => {
+        it("can be formatted as string and then roundtripped back into BUrn", () => {
+          const stringValue = format(burn);
+          expect(stringValue).toEqual(asString);
+          expect(parse(stringValue)).toEqual(burn);
+        });
+
+        it("can be formatted as shorthand string and then roundtripped back into BUrn", () => {
+          const stringValue = format(burn, { shorthand: true });
+          expect(stringValue).toEqual(shorthand);
+          expect(parse(stringValue)).toEqual(burn);
+        });
+
+        describe(`encrypted ${asString}`, () => {
+          it("can be formatted as an encrypted string and then roundtripped back into BUrn", () => {
+            const stringValue = format(burn, { encrypt: true });
+            expect(stringValue.startsWith("bnb:encrypted:")).toBeTruthy();
+            expect(stringValue).not.toContain(burn.system);
+            expect(stringValue).not.toContain(burn.resource);
+            expect(parse(stringValue)).toEqual(burn);
+          });
+
+          it("can be formatted as an encrypted shorthand string and then roundtripped back into BUrn", () => {
+            const stringValue = format(burn, {
+              shorthand: true,
+              encrypt: true,
+            });
+            expect(stringValue.startsWith("bnb:x:")).toBeTruthy();
+            expect(stringValue).not.toContain(burn.system);
+            expect(stringValue).not.toContain(burn.resource);
+            expect(parse(stringValue)).toEqual(burn);
+          });
+        });
+      });
+    });
+  });
+
+  describe("formatForURL", () => {
+    describe("external", () => {
+      it("should be encrypted", () => {
+        const burn = {
+          system: "external",
+          resource: "http://example.com/foo.jpg",
+        };
+        const formatted = formatForURL(burn);
+        expect(formatted.startsWith("bnb:x:")).toBeTruthy();
+        expect(formatted).not.toContain("http://example.com/foo.jpg");
+
+        expect(parse(formatted)).toEqual(burn);
+      });
+    });
+
+    describe("not external", () => {
+      it("should be shorthand form", () => {
+        expect(formatForURL({ system: "internal", resource: "foo" })).toEqual(
+          "bnb:i:foo"
+        );
+        expect(
+          formatForURL({ system: "subsonic", resource: "foo:bar" })
+        ).toEqual("bnb:s:foo:bar");
+      });
+    });
+  });
+
+  describe("assertSystem", () => {
+    it("should fail if the system is not equal", () => {
+      const burn = { system: "external", resource: "something"};
+      expect(() => assertSystem(burn, "subsonic")).toThrow(`Unsupported urn: '${format(burn)}'`)
+    });
+
+    it("should pass if the system is equal", () => {
+      const burn = { system: "external", resource: "something"};
+      expect(assertSystem(burn, "external")).toEqual(burn);
+    });
+  });
+});
+