100% test coverage

turt2live · turt2live · commit e4afa9fa5668 · 2022-12-01T17:38:37.000-07:00
diff --git a/src/ExtensibleEvents.ts b/src/ExtensibleEvents.ts
@@ -36,6 +36,8 @@ export type EventInterpreter<TContentIn extends object = object, TEvent extends
  * on use-case.
  */
 export class ExtensibleEvents {
+    // Dev note: this is manually reset by the unit tests - adjust name in both places
+    // if changed.
     private static _defaultInstance: ExtensibleEvents = new ExtensibleEvents();
 
     private interpreters = new NamespacedMap<EventInterpreter<any>>([
@@ -65,7 +67,7 @@ export class ExtensibleEvents {
      * event types.
      */
     public get unknownInterpretOrder(): NamespacedValue<string, string>[] {
-        return this._unknownInterpretOrder ?? [];
+        return this._unknownInterpretOrder;
     }
 
     /**
@@ -133,8 +135,16 @@ export class ExtensibleEvents {
 
             for (const tryType of this.unknownInterpretOrder) {
                 if (this.interpreters.has(tryType)) {
-                    const val = this.interpreters.get(tryType)!(wireFormat);
-                    if (val) return val;
+                    try {
+                        const val = this.interpreters.get(tryType)!(wireFormat);
+                        if (val) return val;
+                    } catch (e) {
+                        if (e instanceof InvalidEventError) {
+                            continue; // clearly can't be parsed as the unknown type
+                        }
+                        // noinspection ExceptionCaughtLocallyJS
+                        throw e; // re-throw everything else
+                    }
                 }
             }
 
diff --git a/src/events/PollEndEvent.ts b/src/events/PollEndEvent.ts
@@ -46,7 +46,8 @@ export class PollEndEvent extends ExtensibleEvent<M_POLL_END_EVENT_CONTENT> {
         super(wireFormat);
 
         const rel = this.wireContent["m.relates_to"];
-        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== "string") {
+        // noinspection SuspiciousTypeOfGuard
+        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel.event_id !== "string") {
             throw new InvalidEventError("Relationship must be a reference to an event");
         }
 
diff --git a/src/events/PollResponseEvent.ts b/src/events/PollResponseEvent.ts
@@ -61,7 +61,8 @@ export class PollResponseEvent extends ExtensibleEvent<M_POLL_RESPONSE_EVENT_CON
         super(wireFormat);
 
         const rel = this.wireContent["m.relates_to"];
-        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== "string") {
+        // noinspection SuspiciousTypeOfGuard
+        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel.event_id !== "string") {
             throw new InvalidEventError("Relationship must be a reference to an event");
         }
 
@@ -79,7 +80,7 @@ export class PollResponseEvent extends ExtensibleEvent<M_POLL_RESPONSE_EVENT_CON
      */
     public validateAgainst(poll: Optional<PollStartEvent>): void {
         const response = M_POLL_RESPONSE.findIn<M_POLL_RESPONSE_SUBTYPE>(this.wireContent);
-        if (!response?.answers || !Array.isArray(response?.answers)) {
+        if (!response?.answers || !Array.isArray(response.answers)) {
             this.internalSpoiled = true;
             this.internalAnswerIds = [];
             return;
diff --git a/src/interpreters/legacy/MRoomMessage.ts b/src/interpreters/legacy/MRoomMessage.ts
@@ -38,9 +38,11 @@ export function parseMRoomMessage(wireEvent: IPartialEvent<IPartialLegacyContent
         return new MessageEvent(wireEvent as unknown as IPartialEvent<M_MESSAGE_EVENT_CONTENT>);
     }
 
-    const msgtype = wireEvent.content?.msgtype;
-    const text = wireEvent.content?.body;
-    const html = wireEvent.content?.format === "org.matrix.custom.html" ? wireEvent.content.formatted_body : null;
+    if (!wireEvent.content) return null;
+
+    const msgtype = wireEvent.content.msgtype;
+    const text = wireEvent.content.body;
+    const html = wireEvent.content.format === "org.matrix.custom.html" ? wireEvent.content.formatted_body : null;
 
     if (msgtype === "m.text") {
         return new MessageEvent({
diff --git a/test/ExtensibleEvents.test.ts b/test/ExtensibleEvents.test.ts
@@ -19,6 +19,7 @@ import {
     EventType,
     ExtensibleEvent,
     ExtensibleEvents,
+    InvalidEventError,
     IPartialEvent,
     IPartialLegacyContent,
     M_EMOTE,
@@ -44,10 +45,15 @@ import {
 } from "../src";
 
 describe("ExtensibleEvents", () => {
-    // Note: we don't test the other static functions because it should be pretty
-    // obvious when they fail. We'll just make sure that the static accessor works.
-    it("should return an instance by default", () => {
-        expect(ExtensibleEvents.defaultInstance).toBeDefined();
+    afterEach(() => {
+        // gutwrench the default instance into something safe/new to "reset" it
+        (<any>ExtensibleEvents)._defaultInstance = new ExtensibleEvents();
+    });
+
+    describe("static api", () => {
+        it("should return an instance by default", () => {
+            expect(ExtensibleEvents.defaultInstance).toBeDefined();
+        });
     });
 
     describe("unknown events", () => {
@@ -84,6 +90,23 @@ describe("ExtensibleEvents", () => {
             const event = new ExtensibleEvents().parse(input);
             expect(event).toBeFalsy();
         });
+
+        describe("static api", () => {
+            afterEach(() => {
+                ExtensibleEvents.unknownInterpretOrder = new ExtensibleEvents().unknownInterpretOrder;
+            });
+
+            it("should persist the unknown interpret order", () => {
+                expect(ExtensibleEvents.unknownInterpretOrder.length).toBeGreaterThan(0);
+
+                const testValue1 = new UnstableValue(null, "org.matrix.example.feature1");
+                const testValue2 = new UnstableValue(null, "org.matrix.example.feature2");
+                const array = [testValue1, testValue2];
+                ExtensibleEvents.unknownInterpretOrder = array;
+
+                expect(ExtensibleEvents.unknownInterpretOrder).toBe(array);
+            });
+        });
     });
 
     describe("custom events", () => {
@@ -149,6 +172,25 @@ describe("ExtensibleEvents", () => {
             expect(event).toBeDefined();
             expect(event instanceof MyCustomEvent).toBe(true);
         });
+
+        describe("static api", () => {
+            it("should support custom interpreters", () => {
+                const input: IPartialEvent<any> = {
+                    type: myNamespace.name,
+                    content: {
+                        hello: "world",
+                    },
+                };
+
+                let event = ExtensibleEvents.parse(input);
+                expect(event).toBeFalsy();
+
+                ExtensibleEvents.registerInterpreter(myNamespace, myInterpreter);
+                event = ExtensibleEvents.parse(input);
+                expect(event).toBeDefined();
+                expect(event instanceof MyCustomEvent).toBe(true);
+            });
+        });
     });
 
     describe("known events", () => {
@@ -278,4 +320,54 @@ describe("ExtensibleEvents", () => {
             expect(poll instanceof PollEndEvent).toBe(true);
         });
     });
+
+    describe("parse errors", () => {
+        function myForcedInvalidInterpreter(wireEvent: IPartialEvent<any>): ExtensibleEvent {
+            throw new InvalidEventError("deliberate throw of invalid type");
+        }
+
+        function myExplodingInterpreter(wireEvent: IPartialEvent<any>): ExtensibleEvent {
+            throw new Error("deliberate throw");
+        }
+
+        it("should return null when InvalidEventError is raised", () => {
+            const extev = new ExtensibleEvents();
+            const namespace = new UnstableValue(null, "org.matrix.example");
+            extev.registerInterpreter(namespace, myForcedInvalidInterpreter);
+            const result = extev.parse({type: namespace.name, content: {unused: true}});
+            expect(result).toBeNull();
+        });
+
+        it("should return null when no known parser is found", () => {
+            const extev = new ExtensibleEvents();
+            const namespace = new UnstableValue(null, "org.matrix.example");
+            const result = extev.parse({type: namespace.name, content: {unused: true}});
+            expect(result).toBeNull();
+        });
+
+        it("should throw if the parser throws an unknown error", () => {
+            const extev = new ExtensibleEvents();
+            const namespace = new UnstableValue(null, "org.matrix.example");
+            extev.registerInterpreter(namespace, myExplodingInterpreter);
+            expect(() => extev.parse({type: namespace.name, content: {unused: true}})).toThrow("deliberate throw");
+        });
+
+        it("should throw if the parser throws an unknown error during unknown interpret order", () => {
+            const extev = new ExtensibleEvents();
+            const namespace = new UnstableValue(null, "org.matrix.example");
+            const namespace2 = new UnstableValue(null, "org.matrix.example2");
+            extev.registerInterpreter(namespace, myExplodingInterpreter);
+            extev.unknownInterpretOrder = [namespace];
+            expect(() => extev.parse({type: namespace2.name, content: {unused: true}})).toThrow("deliberate throw");
+        });
+
+        describe("static api", () => {
+            it("should return null when InvalidEventError is raised", () => {
+                const namespace = new UnstableValue(null, "org.matrix.example");
+                ExtensibleEvents.registerInterpreter(namespace, myForcedInvalidInterpreter);
+                const result = ExtensibleEvents.parse({type: namespace.name, content: {unused: true}});
+                expect(result).toBeNull();
+            });
+        });
+    });
 });
diff --git a/test/NamespacedMap.test.ts b/test/NamespacedMap.test.ts
@@ -63,6 +63,29 @@ describe("NamespacedMap", () => {
         expect(map.get(STABLE_UNSTABLE_NS)).toBe("val1");
     });
 
+    it("should lookup by altName (unstable) if it is the only option", () => {
+        const map = asTestableMap(new NamespacedMap<string>());
+        map.set(STABLE_UNSTABLE_NS, "val1");
+        const tempNs = new NamespacedValue("wrong_stable", STABLE_UNSTABLE_NS.unstable);
+        expect(map.internalMap.size).toBe(2);
+        expect(map.internalMap.get(tempNs.name ?? "TEST_FAIL")).toBeUndefined();
+        expect(map.internalMap.get(tempNs.altName ?? "TEST_FAIL")).toBe("val1");
+        expect(map.hasNamespaced(tempNs.name ?? "TEST_FAIL")).toBe(false);
+        expect(map.hasNamespaced(tempNs.altName ?? "TEST_FAIL")).toBe(true);
+        expect(map.getNamespaced(tempNs.name ?? "TEST_FAIL")).toBeUndefined();
+        expect(map.getNamespaced(tempNs.altName ?? "TEST_FAIL")).toBe("val1");
+        expect(map.has(tempNs)).toBe(true);
+        expect(map.get(tempNs)).toBe("val1");
+    });
+
+    describe("get", () => {
+        it("should return null if no valid keys are found", () => {
+            const map = asTestableMap(new NamespacedMap<string>());
+            expect(map.internalMap.size).toBe(0);
+            expect(map.get(STABLE_UNSTABLE_NS)).toBeNull();
+        });
+    });
+
     it("should only set stable if available", () => {
         const map = asTestableMap(new NamespacedMap<string>());
         map.set(STABLE_ONLY_NS, "val1");
diff --git a/test/NamespacedValue.test.ts b/test/NamespacedValue.test.ts
@@ -30,18 +30,18 @@ describe("NamespacedValue", () => {
 
     it("should support optionally stable values", () => {
         const ns = new NamespacedValue(null, UNSTABLE_VALUE);
-        expect(ns.stable).toBe(null);
+        expect(ns.stable).toBeNull();
         expect(ns.unstable).toBe(UNSTABLE_VALUE);
         expect(ns.name).toBe(UNSTABLE_VALUE);
-        expect(ns.altName).toBe(null);
+        expect(ns.altName).toBeNull();
     });
 
     it("should support optionally unstable values", () => {
         const ns = new NamespacedValue(STABLE_VALUE, null);
         expect(ns.stable).toBe(STABLE_VALUE);
-        expect(ns.unstable).toBe(null);
+        expect(ns.unstable).toBeNull();
         expect(ns.name).toBe(STABLE_VALUE);
-        expect(ns.altName).toBe(null);
+        expect(ns.altName).toBeNull();
     });
 
     it("should not support entirely optional values", () => {
@@ -138,10 +138,10 @@ describe("UnstableValue", () => {
 
     it("should support optionally stable values", () => {
         const ns = new UnstableValue(null, UNSTABLE_VALUE);
-        expect(ns.stable).toBe(null);
+        expect(ns.stable).toBeNull();
         expect(ns.unstable).toBe(UNSTABLE_VALUE);
         expect(ns.name).toBe(UNSTABLE_VALUE);
-        expect(ns.altName).toBe(null);
+        expect(ns.altName).toBeNull();
     });
 
     it("should not support optionally unstable values", () => {
@@ -210,6 +210,11 @@ describe("UnstableValue", () => {
             const ns = new UnstableValue(STABLE_VALUE, UNSTABLE_VALUE);
             expect(ns.findIn(obj)).toBeFalsy();
         });
+
+        it.each([null, undefined])("shouldn't explode when given a %s object", obj => {
+            const ns = new UnstableValue(STABLE_VALUE, UNSTABLE_VALUE);
+            expect(ns.findIn(obj)).toBeFalsy();
+        });
     });
 
     describe("includedIn", () => {
diff --git a/test/events/MessageEvent.test.ts b/test/events/MessageEvent.test.ts
@@ -83,6 +83,28 @@ describe("MessageEvent", () => {
         expect(message.renderings.some(r => r.mimetype === "text/markdown" && r.body === "MD here")).toBe(true);
     });
 
+    it("should not find HTML if there isn't any", () => {
+        const input: IPartialEvent<M_MESSAGE_EVENT_CONTENT> = {
+            type: "org.example.message-like",
+            content: {
+                [M_MESSAGE.name]: [
+                    {body: "Text here", mimetype: "text/plain"},
+                    {body: "MD here", mimetype: "text/markdown"},
+                ],
+
+                // These should be ignored
+                [M_TEXT.name]: "WRONG Text here",
+                [M_HTML.name]: "WRONG HTML here",
+            },
+        };
+        const message = new MessageEvent(input);
+        expect(message.text).toBe("Text here");
+        expect(message.html).toBeUndefined();
+        expect(message.renderings.length).toBe(2);
+        expect(message.renderings.some(r => r.mimetype === "text/plain" && r.body === "Text here")).toBe(true);
+        expect(message.renderings.some(r => r.mimetype === "text/markdown" && r.body === "MD here")).toBe(true);
+    });
+
     it("should fail to parse missing text", () => {
         const input: IPartialEvent<M_MESSAGE_EVENT_CONTENT> = {
             type: "org.example.message-like",
diff --git a/test/events/PollEndEvent.test.ts b/test/events/PollEndEvent.test.ts
@@ -109,4 +109,13 @@ describe("PollEndEvent", () => {
             });
         });
     });
+
+    describe("isEquivalentTo", () => {
+        it("should consider itself the same for M_POLL_END types", () => {
+            const event = PollEndEvent.from("$poll", "Poll closed");
+            expect(event.isEquivalentTo(M_POLL_END.name)).toBe(true);
+            expect(event.isEquivalentTo(M_POLL_END.altName)).toBe(true);
+            expect(event.isEquivalentTo("org.matrix.random")).toBe(false);
+        });
+    });
 });
diff --git a/test/events/PollResponseEvent.test.ts b/test/events/PollResponseEvent.test.ts
@@ -114,6 +114,23 @@ describe("PollResponseEvent", () => {
     });
 
     describe("validateAgainst", () => {
+        it("should spoil the vote when no response subevent", () => {
+            const input: IPartialEvent<M_POLL_RESPONSE_EVENT_CONTENT> = {
+                type: M_POLL_RESPONSE.name,
+                content: {
+                    "m.relates_to": {
+                        rel_type: REFERENCE_RELATION.name,
+                        event_id: "$poll",
+                    },
+                } as any, // force invalid type
+            };
+            const response = new PollResponseEvent(input);
+            expect(response.spoiled).toBe(true);
+
+            response.validateAgainst(SAMPLE_POLL);
+            expect(response.spoiled).toBe(true);
+        });
+
         it("should spoil the vote when no answers", () => {
             const input: IPartialEvent<M_POLL_RESPONSE_EVENT_CONTENT> = {
                 type: M_POLL_RESPONSE.name,
@@ -192,6 +209,26 @@ describe("PollResponseEvent", () => {
             expect(response.spoiled).toBe(true);
         });
 
+        it("should spoil the vote when answers is not an array", () => {
+            const input: IPartialEvent<M_POLL_RESPONSE_EVENT_CONTENT> = {
+                type: M_POLL_RESPONSE.name,
+                content: {
+                    "m.relates_to": {
+                        rel_type: REFERENCE_RELATION.name,
+                        event_id: "$poll",
+                    },
+                    [M_POLL_RESPONSE.name]: {
+                        answers: "yes",
+                    },
+                } as any, // force invalid type
+            };
+            const response = new PollResponseEvent(input);
+            expect(response.spoiled).toBe(true);
+
+            response.validateAgainst(SAMPLE_POLL);
+            expect(response.spoiled).toBe(true);
+        });
+
         describe("consumer usage", () => {
             it("should spoil the vote when invalid answers are given", () => {
                 const input: IPartialEvent<M_POLL_RESPONSE_EVENT_CONTENT> = {
diff --git a/test/events/PollStartEvent.test.ts b/test/events/PollStartEvent.test.ts
diff --git a/test/interpreters/legacy/MRoomMessage.test.ts b/test/interpreters/legacy/MRoomMessage.test.ts
diff --git a/test/interpreters/modern/MPoll.test.ts b/test/interpreters/modern/MPoll.test.ts
diff --git a/test/utility/MessageMatchers.test.ts b/test/utility/MessageMatchers.test.ts

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,8 @@ export class PollEndEvent extends ExtensibleEvent<M_POLL_END_EVENT_CONTENT> {`
`46`	`46`	`super(wireFormat);`
`47`	`47`
`48`	`48`	`const rel = this.wireContent["m.relates_to"];`
`49`		`- if (!REFERENCE_RELATION.matches(rel?.rel_type) \|\| typeof rel?.event_id !== "string") {`
	`49`	`+ // noinspection SuspiciousTypeOfGuard`
	`50`	`+ if (!REFERENCE_RELATION.matches(rel?.rel_type) \|\| typeof rel.event_id !== "string") {`
`50`	`51`	`throw new InvalidEventError("Relationship must be a reference to an event");`
`51`	`52`	`}`
`52`	`53`