http-request-manager 18.15.34 → 18.16.1

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

@@ -1,665 +0,0 @@
-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);
-  });
-});