fix(operators): cleanup and standardize tests

Author: StephanGerbeth

.vscode/extensions.json

@@ -13,6 +13,7 @@
     "formulahendry.auto-close-tag",
     "formulahendry.auto-rename-tag",
     "naumovs.color-highlight",
-    "humao.rest-client"
+    "humao.rest-client",
+    "techer.open-in-browser"
   ]
 }

packages/mock/async.js

@@ -0,0 +1,3 @@
+import { of } from 'rxjs';
+
+export const mockAsync = v => of(v);

packages/test-utils/network.js renamed to packages/mock/network.js

@@ -0,0 +1,15 @@
+import { vi } from 'vitest';
+
+import { mockAsync } from './async';
+
+export const mockResponse = () => {
+  return vi.fn((e, url) => ({
+    url: url,
+    clone: () => new Response(e),
+    json: () => mockAsync(e),
+    text: () => mockAsync(e),
+    blob: () => mockAsync(e),
+    arrayBuffer: () => mockAsync(e),
+    ok: true
+  }));
+};

packages/mock/response.js

@@ -2,7 +2,7 @@ import { tap } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
 import { beforeEach, test, expect, describe, afterEach } from 'vitest';
 
-import { mockOffline, mockOnline, mockReset } from '../../../test-utils/network.js';
+import { mockOffline, mockOnline, mockReset } from '../../../mock/network.js';
 import { connectionObservable } from './window.js';
 
 // HINT: https://betterprogramming.pub/rxjs-testing-write-unit-tests-for-observables-603af959e251

packages/observables/src/dom/window.test.js

@@ -14,20 +14,20 @@ export const log = tag => {
   if (debug.enabled(tag)) {
     return source => {
       return new Observable(observer => {
-        return source.subscribe(
-          val => {
+        return source.subscribe({
+          next: val => {
             logger(val);
             observer.next(val);
           },
-          err => {
+          error: err => {
             error(err);
             observer.error(err);
           },
-          () => {
+          complete: () => {
             logger(bgGreen.bold('Complete!'));
             observer.complete();
           }
-        );
+        });
       });
     };
   } else {

packages/operators/src/log.js

@@ -1,86 +1,60 @@
-import { concatAll, concatMap, delay, from, map, of, toArray } from 'rxjs';
+import { concatAll, delay, from, map, of } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
-import { afterAll, afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 
-import { log, logOutput, logResult } from '../log';
+import { mockAsync } from '../../../mock/async';
+import { mockResponse } from '../../../mock/response';
+import { log, logResult } from '../log';
 import { resolveJSON } from './response';
 
-describe('auto pagination - mocked', () => {
-  const testScheduler = new TestScheduler((actual, expected) => {
-    expect(actual).to.eql(expected);
-  });
+describe('auto pagination', () => {
+  let testScheduler;
 
-  beforeEach(() => {
-    vi.doMock('./request', importOriginal => ({
-      request: () => source => source.pipe(concatMap(({ v, t }) => of(v).pipe(delay(t))))
-    }));
+  beforeAll(() => {
+    vi.spyOn(global, 'fetch').mockImplementation(({ v, t }) => mockAsync(v).pipe(delay(t)));
 
-    Object.prototype.clone = vi.fn();
-    vi.spyOn(Object.prototype, 'clone').mockImplementation(function (e) {
-      return { ...JSON.parse(JSON.stringify(this)) };
-    });
+    global.Response = mockResponse();
   });
 
-  afterEach(() => {
-    vi.doUnmock('./request');
+  beforeEach(() => {
+    testScheduler = new TestScheduler((actual, expected) => expect(actual).to.eql(expected));
   });
 
   afterAll(() => {
-    vi.resetModules();
+    vi.restoreAllMocks();
   });
 
-  test('classic testing', async () => {
+  test('default', async () => {
     const { autoPagination } = await import('./autoPagination');
 
-    const triggerVal = [
-      { t: 2, v: { value: 'a', next: 1 } },
-      { t: 5, v: { value: 'b', next: 2 } },
-      { t: 3, v: { value: 'c', next: 3 } },
-      { t: 1, v: { value: 'd', next: 4 } },
-      { t: 4, v: { value: 'e', next: null } }
-    ];
-
-    const expectedVal = triggerVal.map(({ v }) => v);
-
-    await new Promise((done, error) => {
-      of(triggerVal[0])
-        .pipe(
-          autoPagination({
-            resolveRoute: (conf, resp) =>
-              ((!resp || resp.next) && [triggerVal[resp?.next || 0]]) || []
-          }),
-          toArray()
-        )
-        .subscribe({
-          next: e => expect(e).toStrictEqual(expectedVal),
-          complete: () => done(),
-          error: () => error()
-        });
-    });
-  });
-
-  test('marble testing', async () => {
-    const { autoPagination } = await import('./autoPagination');
+    const expectedVal = {
+      a: { value: 'a', next: 'b' },
+      b: { value: 'b', next: 'c' },
+      c: { value: 'c', next: 'd' },
+      d: { value: 'd', next: 'e' },
+      e: { value: 'e', next: null }
+    };
 
     const triggerVal = {
-      a: { t: 2, v: { value: 'a', next: 'b' } },
-      b: { t: 5, v: { value: 'b', next: 'c' } },
-      c: { t: 3, v: { value: 'c', next: 'd' } },
-      d: { t: 1, v: { value: 'd', next: 'e' } },
-      e: { t: 4, v: { value: 'e', next: null } }
+      a: { t: 2, v: new Response(expectedVal.a) },
+      b: { t: 5, v: new Response(expectedVal.b) },
+      c: { t: 3, v: new Response(expectedVal.c) },
+      d: { t: 1, v: new Response(expectedVal.d) },
+      e: { t: 4, v: new Response(expectedVal.e) }
     };
 
-    const expectedVal = Object.fromEntries(
-      Array.from(Object.entries(triggerVal)).map(([k, { v }]) => [k, v])
-    );
-
     testScheduler.run(({ cold, expectObservable }) => {
       expectObservable(
-        cold('-a-------------------', triggerVal).pipe(
+        cold('-a-------------------', { a: 'a' }).pipe(
           autoPagination({
-            resolveRoute: (conf, resp) =>
-              ((!resp || resp.next) && [triggerVal[resp?.next || 'a']]) || []
+            resolveRoute: (url, resp) => {
+              if (resp) {
+                return from(resp.json()).pipe(map(({ next }) => triggerVal[String(next)]));
+              }
+              return of(triggerVal[String(url)]);
+            }
           }),
+          resolveJSON(),
           log('marble:result')
         )
       ).toBe('---a----b--cd---e----', expectedVal);
@@ -89,23 +63,25 @@ describe('auto pagination - mocked', () => {
 });
 
 describe('auto pagination - demo', () => {
-  test('sample testing', async () => {
+  test('sample', async () => {
     const { autoPagination } = await import('./autoPagination');
 
     await logResult(
       'demo',
       of(new URL('https://dummyjson.com/products')).pipe(
         autoPagination({
-          resolveRoute: async (url, resp) => {
-            const data = (await resp?.json()) || { skip: -10, limit: 10 };
-
-            if (!data.total || data.total > data.skip + data.limit) {
-              const newUrl = new URL(`${url}`);
-              newUrl.searchParams.set('skip', data.skip + data.limit);
-              newUrl.searchParams.set('limit', data.limit);
-              newUrl.searchParams.set('select', 'title,price');
-              return newUrl;
-            }
+          resolveRoute: (url, resp) => {
+            return from(resp?.json() || of({ skip: -10, limit: 10 })).pipe(
+              map(data => {
+                if (!data.total || data.total > data.skip + data.limit) {
+                  const newUrl = new URL(`${url}`);
+                  newUrl.searchParams.set('skip', data.skip + data.limit);
+                  newUrl.searchParams.set('limit', data.limit);
+                  newUrl.searchParams.set('select', 'title,price');
+                  return newUrl;
+                }
+              })
+            );
           }
         }),
         log('demo:response'),

packages/operators/src/request/autoPagination.test.js

@@ -1,4 +1,4 @@
-import { ReplaySubject, share, tap, timer } from 'rxjs';
+import { ReplaySubject, share, timer } from 'rxjs';
 
 export const cache = ttl => {
   return source =>

packages/operators/src/request/cache.js

@@ -1,31 +1,23 @@
-import fetchMock from 'fetch-mock';
-import { defer, delay, map, of, tap } from 'rxjs';
+import { map } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { beforeEach, describe, expect, test } from 'vitest';
 
 import { cache } from './cache';
-import { requestText } from './request';
 
-describe('cache - mocked', () => {
-  const testScheduler = new TestScheduler((actual, expected) => {
-    expect(actual).deep.equal(expected);
-  });
+describe('cache', () => {
+  let testScheduler;
 
   beforeEach(() => {
-    //
-  });
-
-  afterEach(() => {
-    //
+    testScheduler = new TestScheduler((actual, expected) => expect(actual).deep.equal(expected));
   });
 
-  test('marble testing', () => {
+  test('default', () => {
     const initial = new Response('initial', { status: 200 });
     const updated = new Response('updated', { status: 200 });
     const orderedResponses = [initial, updated];
 
     testScheduler.run(({ cold, expectObservable }) => {
-      const stream = cold('a-----------', {
+      const stream = cold('a', {
         a: () => orderedResponses.shift()
       }).pipe(
         map(fn => fn()),
@@ -42,76 +34,4 @@ describe('cache - mocked', () => {
       expectObservable(stream, unsubC).toBe('---------a', { a: updated }, new Error());
     });
   });
-
-  test('cache resetted after 100ms', async () => {
-    let counter = 0;
-    const a = of(counter).pipe(
-      tap(e => console.log('U', e)),
-      cache(5)
-    );
-
-    defer(() => a)
-      .pipe(delay(2))
-      .subscribe(e => console.log(e));
-    defer(() => a)
-      .pipe(delay(2))
-      .subscribe(e => console.log(e));
-
-    await new Promise(done => setTimeout(done), 500);
-
-    defer(() => a)
-      .pipe(delay(100))
-      .subscribe(e => console.log(e));
-
-    await new Promise(done => setTimeout(done), 1000);
-  });
-});
-
-describe('cache', () => {
-  beforeEach(() => {
-    let counter = 0;
-    fetchMock.mockGlobal().get(
-      'https://httpbin.org/my-url-fast',
-      () =>
-        new Response(++counter, {
-          status: 200,
-          headers: { 'Content-type': 'plain/text' }
-        }),
-      { delay: 0, repeat: 2 }
-    );
-  });
-
-  afterEach(() => {
-    fetchMock.unmockGlobal();
-  });
-
-  test('cache resetted after 100ms', async () => {
-    const a = of('https://httpbin.org/my-url-fast').pipe(
-      requestText(),
-      tap(() => console.log('CHECK')),
-      cache(1000)
-    );
-    await new Promise(done => {
-      a.subscribe({
-        next: e => expect(e).toBe('1'),
-        complete: () => done()
-      });
-    });
-
-    await new Promise(done => {
-      a.subscribe({
-        next: e => expect(e).toBe('1'),
-        complete: () => done()
-      });
-    });
-
-    await new Promise(resolve => setTimeout(resolve, 1000));
-
-    await new Promise(done => {
-      a.subscribe({
-        next: e => expect(e).toBe('2'),
-        complete: () => done()
-      });
-    });
-  });
 });