Merge pull request #38 from nebarf/tests

Tests

Author: nebarf

README.md

@@ -626,8 +626,8 @@ export class HttpSessionStorageCacheStore {
    * @inheritdoc
    */
   flush() {
-    this._keys().forEach((entry) => {
-      this.delete(entry.identifier);
+    this._keys().forEach((itemKey) => {
+      this.delete(itemKey);
     });
   }
 }

jest.config.js

@@ -12,16 +12,15 @@ module.exports = {
   // Runs special logic, such as cleaning up components
   // when using React Testing Library and adds special
   // extended assertions to Jest
-  setupFilesAfterEnv: [
-    // '@testing-library/react/cleanup-after-each',
-    // '@testing-library/jest-dom/extend-expect',
-  ],
+  setupFilesAfterEnv: ['./setup-jest.ts'],
 
   // Test spec file resolution pattern
   // Matches parent folder `__tests__` and filename
-  // should contain `test` or `spec`.
-  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+  // should contain `spec`.
+  testRegex: '/__tests__/.*.spec.(ts|tsx)?$',
 
   // Module file extensions for importing
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+
+  testEnvironment: 'jsdom',
 };

package.json

@@ -34,6 +34,8 @@
     "eslint-plugin-react-hooks": "^4.2.0",
     "husky": "^7.0.0",
     "jest": "^27.2.4",
+    "jest-fetch-mock": "^3.0.3",
+    "jest-mock-extended": "^2.0.4",
     "lint-staged": "^11.2.0",
     "prettier": "^2.4.1",
     "react": "^17.0.2",
@@ -64,8 +66,8 @@
     "release:patch": "release-it patch",
     "release:minor": "release-it minor",
     "release:major": "release-it major",
-    "test": "jest -c ./jest.config.js",
-    "test:watch": "jest -c ./jest.config.js --watch"
+    "test": "jest -c ./jest.config.js --env=jsdom",
+    "test:watch": "jest -c ./jest.config.js --watch --env=jsdom"
   },
   "peerDependencies": {
     "react": "^17.0.2",

setup-jest.ts

@@ -0,0 +1,3 @@
+import { enableFetchMocks } from 'jest-fetch-mock';
+
+enableFetchMocks();

src/__tests__/fixtures/http-cache.fixture.ts

@@ -0,0 +1,14 @@
+import { HttpCacheService, HttpInMemoryCacheStore } from '../../cache';
+import { HttpCacheStorePrefixDecorator } from '../../cache/prefix-decorator';
+
+export class HttpCacheFixture {
+  static defaultStore: HttpCacheStorePrefixDecorator = new HttpCacheStorePrefixDecorator(
+    new HttpInMemoryCacheStore()
+  );
+
+  static create(store?: HttpCacheStorePrefixDecorator): HttpCacheService {
+    const fallenbackStore =
+      store || new HttpCacheStorePrefixDecorator(new HttpInMemoryCacheStore());
+    return new HttpCacheService(fallenbackStore);
+  }
+}

src/__tests__/fixtures/http-client-config-provider.fixture.tsx

@@ -0,0 +1,19 @@
+import React, { ReactElement } from 'react';
+import { HttpClientConfigProvider, HttpClientProviderConfig } from '../..';
+
+export class HttpClientProviderConfigFixture {
+  static create<HttpRequestBodyT = void, HttpResponseT = unknown>(
+    options: Partial<HttpClientProviderConfig<HttpRequestBodyT, HttpResponseT>> = {}
+  ): ({ children }: { children: ReactElement }) => ReactElement {
+    const fallenbackOptions: Partial<HttpClientProviderConfig<HttpRequestBodyT, HttpResponseT>> =
+      options;
+
+    return ({ children }: { children: ReactElement }): ReactElement => {
+      const Provider = (
+        <HttpClientConfigProvider config={fallenbackOptions}>{children}</HttpClientConfigProvider>
+      );
+
+      return Provider;
+    };
+  }
+}

src/__tests__/fixtures/http-request.fixture.ts

@@ -0,0 +1,20 @@
+import { HttpMethod, HttpRequest, HttpRequestProps } from '../..';
+
+export class HttpRequestFixture {
+  static defaultOptions: HttpRequestProps<undefined> = {
+    baseUrl: 'http://rhf.com',
+    method: HttpMethod.Get,
+    relativeUrl: 'comments',
+  };
+
+  static create<HttpRequestBodyT = void>(
+    options?: HttpRequestProps<HttpRequestBodyT>
+  ): HttpRequest<HttpRequestBodyT> {
+    const fallenbackOptions: HttpRequestProps<HttpRequestBodyT> = {
+      ...HttpRequestFixture.defaultOptions,
+      ...options,
+    };
+
+    return new HttpRequest(fallenbackOptions);
+  }
+}

src/__tests__/http-cache.spec.ts

@@ -0,0 +1,125 @@
+import { HttpCacheFixture } from './fixtures/http-cache.fixture';
+import { HttpRequestFixture } from './fixtures/http-request.fixture';
+
+describe('http-fetch', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.spyOn(global, 'setTimeout');
+  });
+
+  test('should return undefined if no cached entry is found for the given identifier', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create();
+    const cachedEntry = httpCache.get(httpRequest);
+
+    expect(cachedEntry).toBeUndefined();
+  });
+
+  test('should return the cached entry corresponding to the provided identifier', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+    });
+
+    const cachedResponse = { name: 'Phelony' };
+
+    httpCache.put(httpRequest, cachedResponse);
+    const expiredCachedResponse = httpCache.get<{ name: string }, void>(httpRequest);
+
+    expect(expiredCachedResponse).toEqual(cachedResponse);
+    expect(setTimeout).toHaveBeenCalledTimes(1);
+    expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 6000);
+  });
+
+  test('should remove the cached entry once expired', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+    });
+
+    const httpResponse = { name: 'Phelony' };
+
+    httpCache.put(httpRequest, httpResponse);
+    const cachedResponse = httpCache.get<{ name: string }, void>(httpRequest);
+
+    expect(cachedResponse).toEqual(httpResponse);
+    expect(setTimeout).toHaveBeenCalledTimes(1);
+    expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 6000);
+
+    jest.runOnlyPendingTimers();
+    const expiredCachedResponse = httpCache.get<{ name: string }, void>(httpRequest);
+    expect(expiredCachedResponse).toBeUndefined();
+  });
+
+  test('should tell if a cached response for a given request is expired', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+    });
+
+    httpCache.put(httpRequest, {});
+    expect(httpCache.isExpired(httpRequest)).toBe(false);
+
+    jest.runOnlyPendingTimers();
+    expect(httpCache.isExpired(httpRequest)).toBe(true);
+  });
+
+  test('should tell if there is a cached response for the given request', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+    });
+
+    httpCache.put(httpRequest, {});
+    expect(httpCache.has(httpRequest)).toBe(true);
+
+    jest.runOnlyPendingTimers();
+    expect(httpCache.has(httpRequest)).toBe(false);
+  });
+
+  test('should prune the cache by removing any expired entry', () => {
+    const httpCache = HttpCacheFixture.create();
+    const httpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+    });
+
+    httpCache.put(httpRequest, {});
+    expect(httpCache.has(httpRequest)).toBe(true);
+
+    jest.runOnlyPendingTimers();
+    expect(httpCache.has(httpRequest)).toBe(false);
+  });
+
+  test('should flush the cache by removing all entries', () => {
+    const httpCache = HttpCacheFixture.create();
+    const firstHttpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+      relativeUrl: 'posts',
+    });
+    const secondHttpRequest = HttpRequestFixture.create({
+      ...HttpRequestFixture.defaultOptions,
+      maxAge: 6000,
+      relativeUrl: 'comments',
+    });
+
+    httpCache.put(firstHttpRequest, {});
+    httpCache.put(secondHttpRequest, {});
+
+    expect(httpCache.has(firstHttpRequest)).toBe(true);
+    expect(httpCache.has(secondHttpRequest)).toBe(true);
+
+    httpCache.flush();
+    expect(httpCache.has(firstHttpRequest)).toBe(false);
+    expect(httpCache.has(secondHttpRequest)).toBe(false);
+  });
+});