@talkpilot/core-db 1.1.3 → 1.1.5

package/src/municipal/systemInstructions/__tests__/getters.spec.ts

@@ -1,35 +1,35 @@
-import { createSystemInstruction } from '../instructions.setters';
+import { createSystemInstruction } from "../instructions.setters";
 import {
   getSystemInstructionById,
   getActiveSystemInstructionsByCity,
   getSystemInstructionsByToolAndCity,
-  findSystemInstructions
-} from '../instructions.getters';
-import { ObjectId } from 'mongodb';
-import { MIS_TOOLS, QUERY_TYPES } from '../instructions.types';
+  findSystemInstructions,
+} from "../instructions.getters";
+import { ObjectId } from "mongodb";
+import { MIS_TOOLS, QUERY_TYPES } from "../instructions.types";
 
-describe('System Instructions Getter Tests', () => {
-  const testCity = 'Ashdod';
-  const otherCity = 'Tel Aviv';
+describe("System Instructions Getter Tests", () => {
+  const testCity = "Ashdod";
+  const otherCity = "Tel Aviv";
 
-  describe('getters', () => {
+  describe("getters", () => {
     let instructionId: string;
 
     beforeEach(async () => {
       const id = await createSystemInstruction({
         cityName: testCity,
-        instruction: 'Find Me',
+        instruction: "Find Me",
         isActive: true,
         tool: MIS_TOOLS.findSubject,
         queryType: QUERY_TYPES.any,
-        tags: ['important', 'urgent']
+        tags: ["important", "urgent"],
       });
       instructionId = id.toString();
-      
+
       // for filtering tests
       await createSystemInstruction({
         cityName: testCity,
-        instruction: 'Inactive One',
+        instruction: "Inactive One",
         isActive: false,
         tool: MIS_TOOLS.findSubject,
         queryType: QUERY_TYPES.any,
@@ -37,62 +37,77 @@ describe('System Instructions Getter Tests', () => {
 
       await createSystemInstruction({
         cityName: otherCity,
-        instruction: 'Other City Instruction',
+        instruction: "Other City Instruction",
         isActive: true,
         tool: MIS_TOOLS.findStreet,
         queryType: QUERY_TYPES.exactlyOne,
       });
     });
 
-    describe('getSystemInstructionById', () => {
-        it('given existing id when fetched then return the document', async () => {
-            const result = await getSystemInstructionById(instructionId);
-            expect(result?._id.toString()).toBe(instructionId);
-        });
+    describe("getSystemInstructionById", () => {
+      it("given existing id when fetched then return the document", async () => {
+        const result = await getSystemInstructionById(instructionId);
+        expect(result?._id.toString()).toBe(instructionId);
+      });
 
-        it('given non-existent id when fetched then return null', async () => {
-            const result = await getSystemInstructionById(new ObjectId().toHexString());
-            expect(result).toBeNull();
-        });
+      it("given non-existent id when fetched then return null", async () => {
+        const result = await getSystemInstructionById(
+          new ObjectId().toHexString(),
+        );
+        expect(result).toBeNull();
+      });
     });
 
-    describe('getActiveSystemInstructionsByCity', () => {
-        it('given city with active instructions when fetched then return only active documents for that city', async () => {
-            const result = await getActiveSystemInstructionsByCity(testCity);
-            expect(result.length).toBe(1);
-            expect(result[0].instruction).toBe('Find Me');
-        });
+    describe("getActiveSystemInstructionsByCity", () => {
+      it("given city with active instructions when fetched then return only active documents for that city", async () => {
+        const result = await getActiveSystemInstructionsByCity(testCity);
+        expect(result.length).toBe(1);
+        expect(result[0].instruction).toBe("Find Me");
+      });
 
-        it('given city with no instructions when fetched then return empty array', async () => {
-            const result = await getActiveSystemInstructionsByCity('NonExistentCity');
-            expect(result).toEqual([]);
-        });
+      it("given city with no instructions when fetched then return empty array", async () => {
+        const result =
+          await getActiveSystemInstructionsByCity("NonExistentCity");
+        expect(result).toEqual([]);
+      });
     });
 
-    describe('getSystemInstructionsByToolAndCity', () => {
-        it('given valid city and tool when fetched then return matching instructions', async () => {
-            const result = await getSystemInstructionsByToolAndCity(testCity, MIS_TOOLS.findSubject);
-            expect(result.length).toBe(2); // One active, one inactive
-            expect(result.every(r => r.cityName === testCity && r.tool === MIS_TOOLS.findSubject)).toBe(true);
-        });
+    describe("getSystemInstructionsByToolAndCity", () => {
+      it("given valid city and tool when fetched then return matching instructions", async () => {
+        const result = await getSystemInstructionsByToolAndCity(
+          testCity,
+          MIS_TOOLS.findSubject,
+        );
+        expect(result.length).toBe(2); // One active, one inactive
+        expect(
+          result.every(
+            (r) => r.cityName === testCity && r.tool === MIS_TOOLS.findSubject,
+          ),
+        ).toBe(true);
+      });
 
-        it('given valid city but wrong tool when fetched then return empty array', async () => {
-            const result = await getSystemInstructionsByToolAndCity(testCity, MIS_TOOLS.findStreet);
-            expect(result).toEqual([]);
-        });
+      it("given valid city but wrong tool when fetched then return empty array", async () => {
+        const result = await getSystemInstructionsByToolAndCity(
+          testCity,
+          MIS_TOOLS.findStreet,
+        );
+        expect(result).toEqual([]);
+      });
     });
 
-    describe('findSystemInstructions', () => {
-        it('given filter by tags when searched then return matching documents', async () => {
-            const result = await findSystemInstructions({ tags: { $in: ['important'] } });
-            expect(result.length).toBe(1);
-            expect(result[0].instruction).toBe('Find Me');
+    describe("findSystemInstructions", () => {
+      it("given filter by tags when searched then return matching documents", async () => {
+        const result = await findSystemInstructions({
+          tags: { $in: ["important"] },
         });
+        expect(result.length).toBe(1);
+        expect(result[0].instruction).toBe("Find Me");
+      });
 
-        it('given empty filter when searched then return all documents', async () => {
-            const result = await findSystemInstructions({});
-            expect(result.length).toBe(3);
-        });
+      it("given empty filter when searched then return all documents", async () => {
+        const result = await findSystemInstructions({});
+        expect(result.length).toBe(3);
+      });
     });
   });
 });