@futdevpro/nts-dynamo 1.15.92 → 1.15.94

package/src/_services/base/db.service.spec.ts

@@ -1,73 +1,160 @@
-
-import { DyNTS_DBService } from './db.service';
-import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_BasicProperty_Type } from '@futdevpro/fsm-dynamo';
-import * as mongoose from 'mongoose';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-class TestMetadata extends DyFM_Metadata {
-  name: string = '';
-  email: string = '';
-}
-
-const testDataParams: DyFM_DataModel_Params<TestMetadata> = new DyFM_DataModel_Params<TestMetadata>({
-  dataName: 'test_data',
-  properties: {
-    name: {
-      key: 'name',
-      type: DyFM_BasicProperty_Type.string,
-      required: true,
-    },
-    email: {
-      key: 'email',
-      type: DyFM_BasicProperty_Type.string,
-    },
-  },
-});
-
-describe('| DyNTS_DBService', () => {
-  let dbService: DyNTS_DBService<TestMetadata>;
-
-  afterEach(() => {
-    delete (mongoose.models as Record<string, unknown>)['test_data'];
-  });
-
-  describe('| constructor', () => {
-    it('| should create service with valid dataParams', () => {
-      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
-
-      expect(dbService).toBeDefined();
-      expect(dbService.dataParams).toBe(testDataParams);
-      expect(dbService.serviceName).toBe('DyNTS_DBService');
-    });
-
-    it('| should throw error when dataName is not set', () => {
-      const invalidParams = {
-        dataName: '',
-        properties: {
-          name: { key: 'name', type: DyFM_BasicProperty_Type.string },
-          email: { key: 'email', type: DyFM_BasicProperty_Type.string },
-        },
-        constructed: (): boolean => true,
-      } as unknown as DyFM_DataModel_Params<TestMetadata>;
-
-      expect(() => {
-        new DyNTS_DBService<TestMetadata>(invalidParams);
-      }).toThrow();
-    });
-
-    it('| should throw error when dataParams is not constructed', () => {
-      const invalidParams = {
-        dataName: 'test_data',
-        properties: {},
-        constructed: () => false,
-      } as any;
-
-      expect(() => {
-        new DyNTS_DBService<TestMetadata>(invalidParams);
-      }).toThrow();
-    });
-  });
-
-  // getDataById, createData, modifyData, getDataByDependencyId tesztek kiveve: mongoose.model
-  // getter-only, nem mockolható ebben a környezetben.
-});
+
+import { DyNTS_DBService } from './db.service';
+import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_BasicProperty_Type } from '@futdevpro/fsm-dynamo';
+import * as mongoose from 'mongoose';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestMetadata extends DyFM_Metadata {
+  name: string = '';
+  email: string = '';
+}
+
+const testDataParams: DyFM_DataModel_Params<TestMetadata> = new DyFM_DataModel_Params<TestMetadata>({
+  dataName: 'test_data',
+  properties: {
+    name: {
+      key: 'name',
+      type: DyFM_BasicProperty_Type.string,
+      required: true,
+    },
+    email: {
+      key: 'email',
+      type: DyFM_BasicProperty_Type.string,
+    },
+  },
+});
+
+describe('| DyNTS_DBService', () => {
+  let dbService: DyNTS_DBService<TestMetadata>;
+
+  afterEach(() => {
+    delete (mongoose.models as Record<string, unknown>)['test_data'];
+  });
+
+  describe('| constructor', () => {
+    it('| should create service with valid dataParams', () => {
+      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
+
+      expect(dbService).toBeDefined();
+      expect(dbService.dataParams).toBe(testDataParams);
+      expect(dbService.serviceName).toBe('DyNTS_DBService');
+    });
+
+    it('| should throw error when dataName is not set', () => {
+      const invalidParams = {
+        dataName: '',
+        properties: {
+          name: { key: 'name', type: DyFM_BasicProperty_Type.string },
+          email: { key: 'email', type: DyFM_BasicProperty_Type.string },
+        },
+        constructed: (): boolean => true,
+      } as unknown as DyFM_DataModel_Params<TestMetadata>;
+
+      expect(() => {
+        new DyNTS_DBService<TestMetadata>(invalidParams);
+      }).toThrow();
+    });
+
+    it('| should throw error when dataParams is not constructed', () => {
+      const invalidParams = {
+        dataName: 'test_data',
+        properties: {},
+        constructed: () => false,
+      } as any;
+
+      expect(() => {
+        new DyNTS_DBService<TestMetadata>(invalidParams);
+      }).toThrow();
+    });
+  });
+
+  // getDataById, createData, modifyData, getDataByDependencyId tesztek kiveve: mongoose.model
+  // getter-only, nem mockolható ebben a környezetben.
+
+  // BFR-OVERSEER-008 — find() opcionalis projection/limit/sort: a szukites DB-szintre kerul.
+  // A dataModel.find INSTANCE-property-kent spy-olhato (a mongoose.model maga nem — lasd fenti komment),
+  // a visszaadott fake-query chainable + thenable, igy a teljes lancolas assertelheto.
+  describe('| find (BFR-008 query-options)', () => {
+    interface FakeQueryCalls { select?: unknown; sort?: unknown; limit?: unknown; }
+
+    /** Chainable + thenable fake mongoose-query; rogziti a lancolt hivasokat. */
+    function makeFakeQuery(result: TestMetadata[], calls: FakeQueryCalls): {
+      select: (p: unknown) => unknown; sort: (s: unknown) => unknown; limit: (n: unknown) => unknown;
+      then: (onOk: (res: TestMetadata[]) => TestMetadata[]) => Promise<TestMetadata[]>;
+    } {
+      const fake = {
+        select: (p: unknown): unknown => { calls.select = p; return fake; },
+        sort: (s: unknown): unknown => { calls.sort = s; return fake; },
+        limit: (n: unknown): unknown => { calls.limit = n; return fake; },
+        then: (onOk: (res: TestMetadata[]) => TestMetadata[]): Promise<TestMetadata[]> =>
+          Promise.resolve(result).then(onOk),
+      };
+
+      return fake;
+    }
+
+    it('| options nelkul NEM hiv select/sort/limit-et es post-filterrel szuri a torolteket (back-compat)', async () => {
+      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
+      const calls: FakeQueryCalls = {};
+      const alive: TestMetadata = { _id: 'a1', name: 'alive', email: '' } as TestMetadata;
+      const deleted: TestMetadata = { _id: 'd1', name: 'gone', email: '', _deleted: new Date() } as TestMetadata;
+      const findSpy = spyOn(dbService.dataModel as { find: (f: unknown) => unknown }, 'find')
+        .and.returnValue(makeFakeQuery([ alive, deleted ], calls));
+
+      const result: TestMetadata[] = await dbService.find({ name: 'x' } as never);
+
+      // a filter valtozatlanul megy at (nincs query-szintu _deleted-guard options nelkul)
+      expect(findSpy).toHaveBeenCalledWith({ name: 'x' });
+      expect(calls.select).toBeUndefined();
+      expect(calls.sort).toBeUndefined();
+      expect(calls.limit).toBeUndefined();
+      // a torolt dokumentumot a memoriabeli post-filter szuri (regi viselkedes valtozatlan)
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe('alive');
+    });
+
+    it('| options-szal a projection/sort/limit a query-re lancolodik + a _deleted-guard query-szintu', async () => {
+      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
+      const calls: FakeQueryCalls = {};
+      const findSpy = spyOn(dbService.dataModel as { find: (f: unknown) => unknown }, 'find')
+        .and.returnValue(makeFakeQuery([], calls));
+
+      await dbService.find(
+        { name: 'x' } as never,
+        undefined,
+        { projection: { name: 1 }, sort: { name: -1 }, limit: 5 },
+      );
+
+      // a soft-delete szures a QUERY-be kerul (limit/projekcio mellett a post-filter hibas lenne);
+      // `_deleted: null` = Mongo-ban "missing VAGY null" — a `!data._deleted` post-filter ekvivalense
+      expect(findSpy).toHaveBeenCalledWith({ name: 'x', _deleted: null });
+      expect(calls.select).toEqual({ name: 1 });
+      expect(calls.sort).toEqual({ name: -1 });
+      expect(calls.limit).toBe(5);
+    });
+
+    it('| findDeleted=true options-szal: NINCS _deleted-guard a query-ben', async () => {
+      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
+      const calls: FakeQueryCalls = {};
+      const findSpy = spyOn(dbService.dataModel as { find: (f: unknown) => unknown }, 'find')
+        .and.returnValue(makeFakeQuery([], calls));
+
+      await dbService.find({ name: 'x' } as never, true, { limit: 3 });
+
+      expect(findSpy).toHaveBeenCalledWith({ name: 'x' });
+      expect(calls.limit).toBe(3);
+    });
+
+    it('| explicit _deleted filterrel options-szal: a hivo filtere nyer, nincs dupla guard', async () => {
+      dbService = new DyNTS_DBService<TestMetadata>(testDataParams);
+      const calls: FakeQueryCalls = {};
+      const findSpy = spyOn(dbService.dataModel as { find: (f: unknown) => unknown }, 'find')
+        .and.returnValue(makeFakeQuery([], calls));
+
+      await dbService.find({ name: 'x', _deleted: { $ne: null } } as never, undefined, { limit: 2 });
+
+      expect(findSpy).toHaveBeenCalledWith({ name: 'x', _deleted: { $ne: null } });
+      expect(calls.limit).toBe(2);
+    });
+  });
+});