http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/request-manager-state-service/http-manager-state.store.spec.ts

@@ -0,0 +1,665 @@
+import { TestBed } from '@angular/core/testing';
+import { BehaviorSubject, of } from 'rxjs';
+
+import { DataType } from '../../models/data-type.enum';
+import { DatabaseStorage } from '../../models/database-storage.model';
+import { DatabaseManagerService } from '../database-manager-service';
+import { HTTPManagerService } from '../request-manager-services';
+import { LocalStorageManagerService } from '../local-storage-manager-service';
+import { LoggerService } from '../../services/utils/logger.service';
+import { UtilsService } from '../..';
+import { HTTPManagerStateService } from './http-manager-state.store';
+import { ApiRequest, RequestOptions } from './models';
+
+class MockLocalStorageManagerService {
+  private stores: Record<string, any> = {};
+
+  private normalizeStoreName(name: string): string {
+    return String(name).trim().toLowerCase().replace(/\s+/g, '_');
+  }
+
+  createStore(store: { name: string; data: any }): void {
+    this.stores[this.normalizeStoreName(store.name)] = store.data;
+  }
+
+  updateStore(store: { name: string; data: any }): void {
+    const key = this.normalizeStoreName(store.name);
+    this.stores[key] = { ...(this.stores[key] || {}), ...store.data };
+  }
+
+  store$(name: string) {
+    const value = this.stores[this.normalizeStoreName(name)];
+    return of(typeof value === 'undefined' ? null : value);
+  }
+}
+
+class MockLocalStorageManagerWithTracker {
+  stores: Record<string, any> = {};
+
+  private normalizeStoreName(name: string): string {
+    return String(name).trim().toLowerCase().replace(/\s+/g, '_');
+  }
+
+  createStore(store: { name: string; data: any; options?: any }): void {
+    const key = this.normalizeStoreName(store.name);
+    if (key in this.stores) return; // no-op if already exists — mirrors real LocalStorageManagerService behaviour
+    this.stores[key] = store.data;
+  }
+
+  updateStore(store: { name: string; data: any }): void {
+    const key = this.normalizeStoreName(store.name);
+    this.stores[key] = { ...(this.stores[key] || {}), ...store.data };
+  }
+
+  store$(name: string) {
+    const value = this.stores[this.normalizeStoreName(name)];
+    return of(typeof value === 'undefined' ? null : value);
+  }
+
+  storeExists$(name: string) {
+    const key = this.normalizeStoreName(name);
+    return of(key in this.stores);
+  }
+
+  deleteStore(store: { name: string }): void {
+    const key = this.normalizeStoreName(store.name);
+    delete this.stores[key];
+  }
+}
+
+describe('HTTPManagerStateService requestCache.queryParams DB gating', () => {
+  let service: HTTPManagerStateService<any>;
+  let httpManagerService: jasmine.SpyObj<HTTPManagerService<any>>;
+  let dbManagerService: jasmine.SpyObj<DatabaseManagerService>;
+
+  beforeEach(() => {
+    httpManagerService = jasmine.createSpyObj<HTTPManagerService<any>>(
+      'HTTPManagerService',
+      [
+        'getRequest',
+        'connect',
+        'subscribeToChannel',
+        'sendMessageInChannel',
+      ],
+      {
+        error$: of(false),
+        isPending$: of(false),
+        isPending: new BehaviorSubject<boolean>(false),
+        connectionStatus$: of(false),
+        messages$: of(null),
+        subscribedChannels$: of(new Set<string>()),
+      }
+    );
+
+    dbManagerService = jasmine.createSpyObj<DatabaseManagerService>('DatabaseManagerService', [
+      'createDatabaseTable',
+      'databaseExists',
+      'hasDatabaseTable',
+      'getTableRecords',
+      'clearTable',
+      'createTableRecords',
+    ]);
+
+    httpManagerService.getRequest.and.returnValue(of([{ id: 99, name: 'api' }]));
+
+    dbManagerService.createDatabaseTable.and.returnValue(of(true));
+    dbManagerService.databaseExists.and.returnValue(of(true));
+    dbManagerService.hasDatabaseTable.and.returnValue(of(true));
+    dbManagerService.getTableRecords.and.returnValue(of([{ id: 1, name: 'db' }]));
+    dbManagerService.clearTable.and.returnValue(of([]) as any);
+    dbManagerService.createTableRecords.and.returnValue(of([]) as any);
+
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: HTTPManagerService, useValue: httpManagerService },
+        { provide: DatabaseManagerService, useValue: dbManagerService },
+        { provide: LocalStorageManagerService, useClass: MockLocalStorageManagerService },
+        {
+          provide: UtilsService,
+          useValue: {
+            expires: () => Math.floor(Date.now() / 1000) + 3600,
+            hasExpired: () => false,
+          }
+        },
+        {
+          provide: LoggerService,
+          useValue: {
+            debug: () => undefined,
+            info: () => undefined,
+            warn: () => undefined,
+            error: () => undefined,
+          }
+        },
+        {
+          provide: HTTPManagerStateService,
+          useFactory: () => new HTTPManagerStateService(
+            ApiRequest.adapt({ server: 'http://localhost', path: ['oidc', 'api'] }),
+            DataType.ARRAY,
+            DatabaseStorage.adapt({ table: 'state_table', expiresIn: '1d' })
+          ),
+        },
+      ]
+    });
+
+    service = TestBed.inject(HTTPManagerStateService);
+  });
+
+  it('should preserve existing store properties (e.g. schema signature) after updateStore call', () => {
+    const localStorageMock = TestBed.inject(LocalStorageManagerService) as any;
+    const tableName = 'state_table';
+    const key = tableName.trim().toLowerCase().replace(/\s+/g, '_');
+
+    localStorageMock['stores'][key] = { schemaSignature: 'abc123', someOtherProp: 'preserved' };
+
+    service.fetchRecords(RequestOptions.adapt({ path: [{ page: 1, size: 10 }] }));
+
+    const stored = localStorageMock['stores'][key];
+    expect(stored['schemaSignature']).toBeDefined();
+    expect(stored['someOtherProp']).toBe('preserved');
+  });
+
+  it('should skip API for GET when requestCache.GET.queryParams already has the param value', () => {
+    const localStorageMock = TestBed.inject(LocalStorageManagerService) as any;
+    const key = 'state_table';
+    localStorageMock['stores'][key] = {
+      requestCache: {
+        GET: {
+          signature: 'sig',
+          savedAt: Date.now(),
+          path: [{ page: 1, size: 35 }],
+          headers: {},
+          queryParams: { page: ['1'], size: ['35'] },
+          queryParamsExpires: null,
+        }
+      }
+    };
+
+    service.fetchRecords(RequestOptions.adapt({ path: [{ page: 1, size: 35 }] }));
+
+    expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+  });
+
+  it('should call API for GET when requestCache.GET.queryParams has no entry for the path query', () => {
+    service.fetchRecords(RequestOptions.adapt({ path: [{ page: 2, size: 35 }] }));
+
+    expect(httpManagerService.getRequest).toHaveBeenCalled();
+  });
+
+  it('should skip API for STREAM when requestCache.STREAM.queryParams already has the param value', () => {
+    const localStorageMock = TestBed.inject(LocalStorageManagerService) as any;
+    const key = 'state_table';
+    localStorageMock['stores'][key] = {
+      requestCache: {
+        STREAM: {
+          signature: 'sig',
+          savedAt: Date.now(),
+          path: [{ page: 1 }],
+          headers: {},
+          queryParams: { page: ['1'] },
+          queryParamsExpires: null,
+        }
+      }
+    };
+
+    service.fetchStream(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+  });
+
+  it('should call API for STREAM when requestCache.STREAM.queryParams has no entry for the path query', () => {
+    service.fetchStream(RequestOptions.adapt({ path: [{ page: 2 }] }));
+
+    expect(httpManagerService.getRequest).toHaveBeenCalled();
+  });
+
+  it('should call API for GET without database configured regardless of query params', () => {
+    httpManagerService.getRequest.calls.reset();
+
+    const noDbService = TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'http://localhost', path: ['ai', 'pagination'] }),
+      DataType.ARRAY,
+      undefined
+    ));
+
+    noDbService.fetchRecords(RequestOptions.adapt({
+      path: ['ai/pagination?page=0&size=25'],
+    }));
+
+    expect(httpManagerService.getRequest).toHaveBeenCalled();
+  });
+
+  it('should call API for STREAM without database configured regardless of query params', () => {
+    httpManagerService.getRequest.calls.reset();
+
+    const noDbService = TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'http://localhost', path: ['ai', 'pagination'] }),
+      DataType.ARRAY,
+      undefined
+    ));
+
+    noDbService.fetchStream(RequestOptions.adapt({
+      path: ['ai/pagination?page=0&size=25'],
+    }));
+
+    expect(httpManagerService.getRequest).toHaveBeenCalled();
+  });
+});
+
+describe('HTTPManagerStateService tracker refresh race condition', () => {
+  let service: HTTPManagerStateService<any>;
+  let httpManagerService: jasmine.SpyObj<HTTPManagerService<any>>;
+  let dbManagerService: jasmine.SpyObj<DatabaseManagerService>;
+  let localStorageManager: MockLocalStorageManagerWithTracker;
+
+  beforeEach(() => {
+    httpManagerService = jasmine.createSpyObj<HTTPManagerService<any>>(
+      'HTTPManagerService',
+      [
+        'getRequest',
+        'connect',
+        'subscribeToChannel',
+        'sendMessageInChannel',
+      ],
+      {
+        error$: of(false),
+        isPending$: of(false),
+        isPending: new BehaviorSubject<boolean>(false),
+        connectionStatus$: of(false),
+        messages$: of(null),
+        subscribedChannels$: of(new Set<string>()),
+      }
+    );
+
+    dbManagerService = jasmine.createSpyObj<DatabaseManagerService>('DatabaseManagerService', [
+      'createDatabaseTable',
+      'databaseExists',
+      'hasDatabaseTable',
+      'getTableRecords',
+      'clearTable',
+      'createTableRecords',
+    ]);
+
+    httpManagerService.getRequest.and.returnValue(of([{ id: 99, name: 'api' }]));
+
+    dbManagerService.createDatabaseTable.and.returnValue(of(true));
+    dbManagerService.databaseExists.and.returnValue(of(true));
+    dbManagerService.hasDatabaseTable.and.returnValue(of(true));
+    dbManagerService.getTableRecords.and.returnValue(of([{ id: 1, name: 'db' }]));
+    dbManagerService.clearTable.and.returnValue(of([]) as any);
+    dbManagerService.createTableRecords.and.returnValue(of([]) as any);
+
+    localStorageManager = new MockLocalStorageManagerWithTracker();
+
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: HTTPManagerService, useValue: httpManagerService },
+        { provide: DatabaseManagerService, useValue: dbManagerService },
+        { provide: LocalStorageManagerService, useValue: localStorageManager },
+        {
+          provide: UtilsService,
+          useValue: {
+            expires: () => Math.floor(Date.now() / 1000) + 3600,
+            hasExpired: () => false,
+          }
+        },
+        {
+          provide: LoggerService,
+          useValue: {
+            debug: () => undefined,
+            info: () => undefined,
+            warn: () => undefined,
+            error: () => undefined,
+          }
+        },
+      ]
+    });
+  });
+
+  it('should block duplicate API call on refresh when requestCache.GET.queryParams already has the consumed value', (done: DoneFn) => {
+    // Pre-populate store with requestCache.GET.queryParams already containing active=true
+    localStorageManager.createStore({
+      name: 'new-contacts-cache',
+      data: {
+        table: 'new-contacts-cache',
+        expiresIn: '1d',
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        schemaSignature: '["++id","active","name_first","name_last"]',
+        requestCache: {
+          GET: {
+            signature: '{"headers":{},"method":"GET","path":["contacts","location",5,"stream_flattened",{"active":true}],"server":"rest/","stream":true,"streamType":"ai_streaming"}',
+            savedAt: Date.now(),
+            path: ['contacts', 'location', 5, 'stream_flattened', { active: true }],
+            headers: {},
+            queryParams: { active: ['true'] },
+            queryParamsExpires: null,
+          }
+        }
+      }
+    });
+
+    // Create service matching the user's setup:
+    // server: 'rest/', path: ['contacts', 'location'], table: 'new-contacts-cache'
+    const contactsService = TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'rest/', path: ['contacts', 'location'] }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table: 'new-contacts-cache', expiresIn: '1d' })
+    ));
+
+    // Simulate the user's call: loadContactsByLocation(5, true)
+    // which calls: fetchRecords(RequestOptions.adapt({ path: [5, 'stream_flattened', { active: true }] }))
+    httpManagerService.getRequest.calls.reset();
+
+    contactsService.fetchRecords(RequestOptions.adapt({
+      path: [5, 'stream_flattened', { active: true }]
+    }));
+
+    // The tracker should recognize that 'active=true' has already been consumed
+    // and block the API call, returning DB data instead
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+      done();
+    }, 500);
+  });
+
+  it('should allow API call when requestCache.GET has no prior queryParams for the path+query', (done: DoneFn) => {
+    // No queryParams in localStorage - fresh page load with no prior visits
+    localStorageManager.createStore({
+      name: 'new-contacts-cache',
+      data: {
+        table: 'new-contacts-cache',
+        expiresIn: '1d',
+        expires: Math.floor(Date.now() / 1000) + 86400,
+      }
+    });
+
+    const contactsService = TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'rest/', path: ['contacts', 'location'] }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table: 'new-contacts-cache', expiresIn: '1d' })
+    ));
+
+    httpManagerService.getRequest.calls.reset();
+
+    contactsService.fetchRecords(RequestOptions.adapt({
+      path: [5, 'stream_flattened', { active: true }]
+    }));
+
+    // First call - tracker should allow the request since active=true is new
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).toHaveBeenCalled();
+      done();
+    }, 500);
+  });
+
+  it('should block API call when same query param value is already in queryParams but allow a new value', (done: DoneFn) => {
+    // requestCache.GET.queryParams already has active=true consumed, but not active=false
+    localStorageManager.createStore({
+      name: 'new-contacts-cache',
+      data: {
+        table: 'new-contacts-cache',
+        expiresIn: '1d',
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        requestCache: {
+          GET: {
+            signature: '{"headers":{},"method":"GET","path":["contacts","location",5,"stream_flattened",{"active":true}],"server":"rest/"}',
+            savedAt: Date.now(),
+            path: ['contacts', 'location', 5, 'stream_flattened', { active: true }],
+            headers: {},
+            queryParams: { active: ['true'] },
+            queryParamsExpires: null,
+          }
+        }
+      }
+    });
+
+    const contactsService = TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'rest/', path: ['contacts', 'location'] }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table: 'new-contacts-cache', expiresIn: '1d' })
+    ));
+
+    // First call with active=true - should be BLOCKED (already consumed)
+    httpManagerService.getRequest.calls.reset();
+
+    contactsService.fetchRecords(RequestOptions.adapt({
+      path: [5, 'stream_flattened', { active: true }]
+    }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+
+      // Second call with active=false - should be ALLOWED (new value)
+      httpManagerService.getRequest.calls.reset();
+
+      contactsService.fetchRecords(RequestOptions.adapt({
+        path: [5, 'stream_flattened', { active: false }]
+      }));
+
+      setTimeout(() => {
+        expect(httpManagerService.getRequest).toHaveBeenCalled();
+        done();
+      }, 500);
+    }, 500);
+  });
+});
+
+describe('HTTPManagerStateService requestCache.queryParams – unit coverage', () => {
+  let httpManagerService: jasmine.SpyObj<HTTPManagerService<any>>;
+  let dbManagerService: jasmine.SpyObj<DatabaseManagerService>;
+  let localStorageManager: MockLocalStorageManagerWithTracker;
+
+  function buildService(table = 'test-table') {
+    return TestBed.runInInjectionContext(() => new HTTPManagerStateService(
+      ApiRequest.adapt({ server: 'http://localhost', path: ['api'] }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table, expiresIn: '1d' })
+    ));
+  }
+
+  beforeEach(() => {
+    httpManagerService = jasmine.createSpyObj<HTTPManagerService<any>>(
+      'HTTPManagerService',
+      ['getRequest', 'connect', 'subscribeToChannel', 'sendMessageInChannel'],
+      {
+        error$: of(false),
+        isPending$: of(false),
+        isPending: new BehaviorSubject<boolean>(false),
+        connectionStatus$: of(false),
+        messages$: of(null),
+        subscribedChannels$: of(new Set<string>()),
+      }
+    );
+
+    dbManagerService = jasmine.createSpyObj<DatabaseManagerService>('DatabaseManagerService', [
+      'createDatabaseTable', 'databaseExists', 'hasDatabaseTable',
+      'getTableRecords', 'clearTable', 'createTableRecords',
+    ]);
+
+    httpManagerService.getRequest.and.returnValue(of([{ id: 99 }]));
+    dbManagerService.createDatabaseTable.and.returnValue(of(true));
+    dbManagerService.databaseExists.and.returnValue(of(true));
+    dbManagerService.hasDatabaseTable.and.returnValue(of(true));
+    dbManagerService.getTableRecords.and.returnValue(of([{ id: 1 }]));
+    dbManagerService.clearTable.and.returnValue(of([]) as any);
+    dbManagerService.createTableRecords.and.returnValue(of([]) as any);
+
+    localStorageManager = new MockLocalStorageManagerWithTracker();
+
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: HTTPManagerService, useValue: httpManagerService },
+        { provide: DatabaseManagerService, useValue: dbManagerService },
+        { provide: LocalStorageManagerService, useValue: localStorageManager },
+        {
+          provide: UtilsService,
+          useValue: { expires: () => Math.floor(Date.now() / 1000) + 3600, hasExpired: () => false }
+        },
+        {
+          provide: LoggerService,
+          useValue: { debug: () => undefined, info: () => undefined, warn: () => undefined, error: () => undefined }
+        },
+      ]
+    });
+  });
+
+  // 5.1 — first call with a new query param value is allowed; queryParams is populated
+  it('should allow first call with new query param value and populate requestCache.GET.queryParams', (done: DoneFn) => {
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    svc.fetchRecords(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).toHaveBeenCalled();
+      const store = localStorageManager['stores']['test-table'];
+      expect(store?.requestCache?.GET?.queryParams?.page).toContain('1');
+      done();
+    }, 100);
+  });
+
+  // 5.2 — repeat call with same param value is blocked
+  it('should block repeat call when same query param value is already in requestCache.GET.queryParams', (done: DoneFn) => {
+    localStorageManager.createStore({
+      name: 'test-table',
+      data: {
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        requestCache: {
+          GET: { signature: 'sig', savedAt: Date.now(), path: [{ page: 1 }], headers: {},
+                 queryParams: { page: ['1'] }, queryParamsExpires: null }
+        }
+      }
+    });
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    svc.fetchRecords(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+      done();
+    }, 100);
+  });
+
+  // 5.3 — call with a new param value is allowed and appended to queryParams
+  it('should allow call with new param value and append it to requestCache.GET.queryParams', (done: DoneFn) => {
+    localStorageManager.createStore({
+      name: 'test-table',
+      data: {
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        requestCache: {
+          GET: { signature: 'sig', savedAt: Date.now(), path: [{ page: 1 }], headers: {},
+                 queryParams: { page: ['1'] }, queryParamsExpires: null }
+        }
+      }
+    });
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    svc.fetchRecords(RequestOptions.adapt({ path: [{ page: 2 }] }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).toHaveBeenCalled();
+      const store = localStorageManager['stores']['test-table'];
+      expect(store?.requestCache?.GET?.queryParams?.page).toContain('1');
+      expect(store?.requestCache?.GET?.queryParams?.page).toContain('2');
+      done();
+    }, 100);
+  });
+
+  // 5.4 — queryParams survives saveRequestCacheMetadata (T4 write does not wipe T2 write)
+  it('should preserve queryParams in requestCache.GET after saveRequestCacheMetadata runs at T4', (done: DoneFn) => {
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    svc.fetchRecords(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    setTimeout(() => {
+      const store = localStorageManager['stores']['test-table'];
+      // queryParams written at T2 (checkTrackerAllowsRequest) must survive T4 (saveRequestCacheMetadata)
+      expect(store?.requestCache?.GET?.queryParams).toBeDefined();
+      expect(store?.requestCache?.GET?.queryParams?.page).toContain('1');
+      // T4 signature field also present, proving both writes coexist
+      expect(store?.requestCache?.GET?.signature).toBeDefined();
+      done();
+    }, 100);
+  });
+
+  // 5.5 — expired queryParamsExpires resets queryParams and allows the call
+  it('should reset queryParams when queryParamsExpires is in the past and allow the call', (done: DoneFn) => {
+    const pastEpoch = Math.floor(Date.now() / 1000) - 1;
+    localStorageManager.createStore({
+      name: 'test-table',
+      data: {
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        requestCache: {
+          GET: { signature: 'sig', savedAt: Date.now(), path: [{ page: 1 }], headers: {},
+                 queryParams: { page: ['1'] }, queryParamsExpires: pastEpoch }
+        }
+      }
+    });
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    // Same value that was "consumed" — allowed because expiry reset cleared queryParams
+    svc.fetchRecords(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).toHaveBeenCalled();
+      done();
+    }, 100);
+  });
+
+  // 5.6 — ignoreQueryParams excludes listed keys from queryParams and the allow/block decision
+  it('should exclude ignoreQueryParams keys from queryParams and the block decision', (done: DoneFn) => {
+    localStorageManager.createStore({
+      name: 'test-table',
+      data: {
+        expires: Math.floor(Date.now() / 1000) + 86400,
+        requestCache: {
+          GET: { signature: 'sig', savedAt: Date.now(), path: [{ page: 1 }], headers: {},
+                 queryParams: { page: ['1'] }, queryParamsExpires: null }
+        }
+      }
+    });
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    // page=1 is consumed, but status is ignored — only page is evaluated → blocked
+    svc.fetchRecords(RequestOptions.adapt({
+      path: [{ page: 1, status: 'active' }],
+      ignoreQueryParams: ['status'],
+    }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+      const store = localStorageManager['stores']['test-table'];
+      // status must NOT appear in queryParams
+      expect(store?.requestCache?.GET?.queryParams?.status).toBeUndefined();
+      done();
+    }, 100);
+  });
+
+  // 5.7 — STREAM path populates and checks requestCache.STREAM.queryParams
+  it('should populate and check requestCache.STREAM.queryParams for stream requests', (done: DoneFn) => {
+    const svc = buildService();
+    httpManagerService.getRequest.calls.reset();
+
+    // First STREAM call — should be allowed and populate STREAM.queryParams
+    svc.fetchStream(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+    setTimeout(() => {
+      expect(httpManagerService.getRequest).toHaveBeenCalled();
+      const store = localStorageManager['stores']['test-table'];
+      expect(store?.requestCache?.STREAM?.queryParams?.page).toContain('1');
+
+      // Second STREAM call with same value — should be blocked
+      httpManagerService.getRequest.calls.reset();
+      svc.fetchStream(RequestOptions.adapt({ path: [{ page: 1 }] }));
+
+      setTimeout(() => {
+        expect(httpManagerService.getRequest).not.toHaveBeenCalled();
+        done();
+      }, 100);
+    }, 100);
+  });
+});