Improve parsing of sgnl:// hrefs

ts/test/util/sgnlHref_test.ts

@@ -0,0 +1,173 @@
+import { assert } from 'chai';
+import Sinon from 'sinon';
+import { LoggerType } from '../../types/Logging';
+
+import { isSgnlHref, parseSgnlHref } from '../../util/sgnlHref';
+
+function shouldNeverBeCalled() {
+  assert.fail('This should never be called');
+}
+
+const explodingLogger: LoggerType = {
+  fatal: shouldNeverBeCalled,
+  error: shouldNeverBeCalled,
+  warn: shouldNeverBeCalled,
+  info: shouldNeverBeCalled,
+  debug: shouldNeverBeCalled,
+  trace: shouldNeverBeCalled,
+};
+
+describe('sgnlHref', () => {
+  describe('isSgnlHref', () => {
+    it('returns false for non-strings', () => {
+      const logger = {
+        ...explodingLogger,
+        warn: Sinon.spy(),
+      };
+
+      const castToString = (value: unknown): string => value as string;
+
+      assert.isFalse(isSgnlHref(castToString(undefined), logger));
+      assert.isFalse(isSgnlHref(castToString(null), logger));
+      assert.isFalse(isSgnlHref(castToString(123), logger));
+
+      Sinon.assert.calledThrice(logger.warn);
+    });
+
+    it('returns false for invalid URLs', () => {
+      assert.isFalse(isSgnlHref('', explodingLogger));
+      assert.isFalse(isSgnlHref('sgnl', explodingLogger));
+      assert.isFalse(isSgnlHref('sgnl://::', explodingLogger));
+    });
+
+    it('returns false if the protocol is not "sgnl:"', () => {
+      assert.isFalse(isSgnlHref('https://example', explodingLogger));
+      assert.isFalse(
+        isSgnlHref(
+          'https://signal.art/addstickers/?pack_id=abc',
+          explodingLogger
+        )
+      );
+      assert.isFalse(isSgnlHref('signal://example', explodingLogger));
+    });
+
+    it('returns true if the protocol is "sgnl:"', () => {
+      assert.isTrue(isSgnlHref('sgnl://', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example.com', explodingLogger));
+      assert.isTrue(isSgnlHref('SGNL://example', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example?foo=bar', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example/', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example#', explodingLogger));
+
+      assert.isTrue(isSgnlHref('sgnl:foo', explodingLogger));
+
+      assert.isTrue(isSgnlHref('sgnl://user:pass@example', explodingLogger));
+      assert.isTrue(isSgnlHref('sgnl://example.com:1234', explodingLogger));
+      assert.isTrue(
+        isSgnlHref('sgnl://example.com/extra/path/data', explodingLogger)
+      );
+      assert.isTrue(
+        isSgnlHref('sgnl://example/?foo=bar#hash', explodingLogger)
+      );
+    });
+
+    it('accepts URL objects', () => {
+      const invalid = new URL('https://example.com');
+      assert.isFalse(isSgnlHref(invalid, explodingLogger));
+      const valid = new URL('sgnl://example');
+      assert.isTrue(isSgnlHref(valid, explodingLogger));
+    });
+  });
+
+  describe('parseSgnlHref', () => {
+    it('returns a null command for invalid URLs', () => {
+      ['', 'sgnl', 'https://example/?foo=bar'].forEach(href => {
+        assert.deepEqual(parseSgnlHref(href, explodingLogger), {
+          command: null,
+          args: new Map<never, never>(),
+        });
+      });
+    });
+
+    it('parses the command for URLs with no arguments', () => {
+      [
+        'sgnl://foo',
+        'sgnl://foo/',
+        'sgnl://foo?',
+        'SGNL://foo?',
+        'sgnl://user:pass@foo',
+        'sgnl://foo/path/data#hash-data',
+      ].forEach(href => {
+        assert.deepEqual(parseSgnlHref(href, explodingLogger), {
+          command: 'foo',
+          args: new Map<string, string>(),
+        });
+      });
+    });
+
+    it("parses a command's arguments", () => {
+      assert.deepEqual(
+        parseSgnlHref(
+          'sgnl://Foo?bar=baz&qux=Quux&num=123&empty=&encoded=hello%20world',
+          explodingLogger
+        ),
+        {
+          command: 'Foo',
+          args: new Map([
+            ['bar', 'baz'],
+            ['qux', 'Quux'],
+            ['num', '123'],
+            ['empty', ''],
+            ['encoded', 'hello world'],
+          ]),
+        }
+      );
+    });
+
+    it('treats the port as part of the command', () => {
+      assert.propertyVal(
+        parseSgnlHref('sgnl://foo:1234', explodingLogger),
+        'command',
+        'foo:1234'
+      );
+    });
+
+    it('ignores duplicate query parameters', () => {
+      assert.deepPropertyVal(
+        parseSgnlHref('sgnl://x?foo=bar&foo=totally-ignored', explodingLogger),
+        'args',
+        new Map([['foo', 'bar']])
+      );
+    });
+
+    it('ignores other parts of the URL', () => {
+      [
+        'sgnl://foo?bar=baz',
+        'sgnl://foo/?bar=baz',
+        'sgnl://foo/lots/of/path?bar=baz',
+        'sgnl://foo?bar=baz#hash',
+        'sgnl://user:pass@foo?bar=baz',
+      ].forEach(href => {
+        assert.deepEqual(parseSgnlHref(href, explodingLogger), {
+          command: 'foo',
+          args: new Map([['bar', 'baz']]),
+        });
+      });
+    });
+
+    it("doesn't do anything fancy with arrays or objects in the query string", () => {
+      // The `qs` module does things like this, which we don't want.
+      assert.deepPropertyVal(
+        parseSgnlHref('sgnl://x?foo[]=bar&foo[]=baz', explodingLogger),
+        'args',
+        new Map([['foo[]', 'bar']])
+      );
+      assert.deepPropertyVal(
+        parseSgnlHref('sgnl://x?foo[bar][baz]=foobarbaz', explodingLogger),
+        'args',
+        new Map([['foo[bar][baz]', 'foobarbaz']])
+      );
+    });
+  });
+});

ts/util/sgnlHref.ts

@@ -0,0 +1,42 @@
+import { LoggerType } from '../types/Logging';
+
+function parseUrl(value: unknown, logger: LoggerType): null | URL {
+  if (value instanceof URL) {
+    return value;
+  } else if (typeof value === 'string') {
+    try {
+      return new URL(value);
+    } catch (err) {
+      return null;
+    }
+  }
+  logger.warn('Tried to parse a sgnl:// URL but got an unexpected type');
+  return null;
+}
+
+export function isSgnlHref(value: string | URL, logger: LoggerType): boolean {
+  const url = parseUrl(value, logger);
+  return url !== null && url.protocol === 'sgnl:';
+}
+
+type ParsedSgnlHref =
+  | { command: null; args: Map<never, never> }
+  | { command: string; args: Map<string, string> };
+export function parseSgnlHref(
+  href: string,
+  logger: LoggerType
+): ParsedSgnlHref {
+  const url = parseUrl(href, logger);
+  if (!url || !isSgnlHref(url, logger)) {
+    return { command: null, args: new Map<never, never>() };
+  }
+
+  const args = new Map<string, string>();
+  url.searchParams.forEach((value, key) => {
+    if (!args.has(key)) {
+      args.set(key, value);
+    }
+  });
+
+  return { command: url.host, args };
+}