feat: add tests for code prediction and stream connection with xCortiRetentionPolicy

Author: markitosha

tests/custom/codes.predict.integration.ts

@@ -156,6 +156,54 @@ describe("cortiClient.codes.predict", () => {
             expect(consoleWarnSpy).not.toHaveBeenCalled();
         });
 
+        it("should predict codes with system icd10int-outpatient without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const result = await cortiClient.codes.predict({
+                system: ["icd10int-outpatient"],
+                context: [{ type: "text", text: faker.lorem.sentence() }],
+            });
+
+            expect(result).toBeDefined();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should predict codes with system icd10int-inpatient without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const result = await cortiClient.codes.predict({
+                system: ["icd10int-inpatient"],
+                context: [{ type: "text", text: faker.lorem.sentence() }],
+            });
+
+            expect(result).toBeDefined();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should predict codes with system icd10uk-outpatient without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const result = await cortiClient.codes.predict({
+                system: ["icd10uk-outpatient"],
+                context: [{ type: "text", text: faker.lorem.sentence() }],
+            });
+
+            expect(result).toBeDefined();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should predict codes with system icd10uk-inpatient without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const result = await cortiClient.codes.predict({
+                system: ["icd10uk-inpatient"],
+                context: [{ type: "text", text: faker.lorem.sentence() }],
+            });
+
+            expect(result).toBeDefined();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+
         it("should predict codes with multiple systems without errors or warnings", async () => {
             expect.assertions(2);
 

tests/custom/stream.connect.integration.ts

@@ -52,6 +52,7 @@ describe("cortiClient.stream.connect", () => {
                 id: interactionId,
                 awaitConfiguration: false,
                 configuration: {
+                    xCortiRetentionPolicy: "retain",
                     transcription: {
                         primaryLanguage: "en",
                         isDiarization: true,
@@ -95,6 +96,7 @@ describe("cortiClient.stream.connect", () => {
                 streamSocket.sendConfiguration({
                     type: "config",
                     configuration: {
+                        xCortiRetentionPolicy: "retain",
                         transcription: {
                             primaryLanguage: "en",
                             isDiarization: true,
@@ -125,6 +127,74 @@ describe("cortiClient.stream.connect", () => {
         });
     });
 
+    describe("should connect with all xCortiRetentionPolicy enum values", () => {
+        it("should connect with xCortiRetentionPolicy retain without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const interactionId = await createTestInteraction(cortiClient, createdInteractionIds);
+
+            const streamSocket = await cortiClient.stream.connect({
+                id: interactionId,
+                awaitConfiguration: false,
+                configuration: {
+                    xCortiRetentionPolicy: "retain",
+                    transcription: {
+                        primaryLanguage: "en",
+                        participants: [
+                            {
+                                channel: 0,
+                                role: "doctor",
+                            },
+                        ],
+                    },
+                    mode: {
+                        type: "facts",
+                        outputLocale: "en-US",
+                    },
+                },
+            });
+            activeSockets.push(streamSocket);
+
+            await waitForWebSocketMessage(streamSocket, "CONFIG_ACCEPTED", { rejectOnWrongMessage: true });
+
+            expect(streamSocket.socket.readyState).toBe(1); // OPEN
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should connect with xCortiRetentionPolicy none without errors or warnings", async () => {
+            expect.assertions(2);
+
+            const interactionId = await createTestInteraction(cortiClient, createdInteractionIds);
+
+            const streamSocket = await cortiClient.stream.connect({
+                id: interactionId,
+                awaitConfiguration: false,
+                configuration: {
+                    xCortiRetentionPolicy: "none",
+                    transcription: {
+                        primaryLanguage: "en",
+                        participants: [
+                            {
+                                channel: 0,
+                                role: "doctor",
+                            },
+                        ],
+                    },
+                    mode: {
+                        type: "facts",
+                        outputLocale: "en-US",
+                    },
+                },
+            });
+            activeSockets.push(streamSocket);
+
+            await waitForWebSocketMessage(streamSocket, "CONFIG_ACCEPTED", { rejectOnWrongMessage: true });
+
+            expect(streamSocket.socket.readyState).toBe(1); // OPEN
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+    });
+
     describe("should connect with different participant roles", () => {
         it("should connect with doctor role", async () => {
             expect.assertions(2);