fixup! feat!: coldObservableProvider now stops after maxRetries (defaults to 10) and logs errors - coldObservableProvider constructor now requires a logger object

Author: mirceahasegan

packages/util-rxjs/test/coldObservableProvider.test.ts

@@ -1,27 +1,25 @@
 import { BehaviorSubject, EmptyError, Subject, firstValueFrom, lastValueFrom, tap } from 'rxjs';
 import { InvalidStringError } from '@cardano-sdk/util';
-import { Logger } from 'ts-log';
 import { RetryBackoffConfig, retryBackoff } from 'backoff-rxjs';
+import { TestLogger, createLogger } from '@cardano-sdk/util-dev';
 import { coldObservableProvider } from '../src';
 
 // There might be a more elegant way to mock with original implementation (spy)
 jest.mock('backoff-rxjs', () => ({
   retryBackoff: jest.fn().mockImplementation((...args) => jest.requireActual('backoff-rxjs').retryBackoff(...args))
 }));
 
-const createMockLogger = (): Logger => ({
-  debug: jest.fn(),
-  error: jest.fn(),
-  info: jest.fn(),
-  trace: jest.fn(),
-  warn: jest.fn()
-});
-
 describe('coldObservableProvider', () => {
+  let logger: TestLogger;
+  const testErrorStr = 'Test error';
+
+  beforeEach(() => {
+    logger = createLogger({ record: true });
+  });
+
   it('returns an observable that calls underlying provider on each subscription and uses retryBackoff', async () => {
     const underlyingProvider = jest.fn().mockResolvedValue(true);
     const backoffConfig: RetryBackoffConfig = { initialInterval: 1 };
-    const logger = createMockLogger();
     const provider$ = coldObservableProvider({
       logger,
       provider: underlyingProvider,
@@ -38,7 +36,6 @@ describe('coldObservableProvider', () => {
     const underlyingProvider = () => firstValueFrom(fakeProviderSubject);
     const backoffConfig: RetryBackoffConfig = { initialInterval: 1 };
     const cancel$ = new BehaviorSubject<boolean>(true);
-    const logger = createMockLogger();
     const provider$ = coldObservableProvider({
       cancel$,
       logger,
@@ -55,7 +52,6 @@ describe('coldObservableProvider', () => {
   });
 
   it('retries using retryBackoff, when underlying provider rejects', async () => {
-    const logger = createMockLogger();
     const underlyingProvider = jest.fn().mockRejectedValueOnce(false).mockResolvedValue(true);
     const retryBackoffConfig: RetryBackoffConfig = { initialInterval: 1 };
     const provider$ = coldObservableProvider({ logger, provider: underlyingProvider, retryBackoffConfig });
@@ -67,10 +63,9 @@ describe('coldObservableProvider', () => {
   it('does not retry, when underlying provider rejects with InvalidStringError', async () => {
     const testValue = { test: 'value' };
     const testError = new InvalidStringError('Test invalid string error');
-    const logger = createMockLogger();
     const underlyingProvider = jest
       .fn()
-      .mockRejectedValueOnce(new Error('Test error'))
+      .mockRejectedValueOnce(new Error(testErrorStr))
       .mockResolvedValueOnce(testValue)
       .mockRejectedValueOnce(testError)
       .mockResolvedValueOnce(testValue);
@@ -86,7 +81,12 @@ describe('coldObservableProvider', () => {
     await expect(firstValueFrom(provider$)).rejects.toThrow(EmptyError);
     expect(underlyingProvider).toBeCalledTimes(3);
     expect(onFatalError).toBeCalledWith(testError);
-    expect(logger.error).toBeCalledWith(testError);
+    expect(logger.messages).toStrictEqual([
+      { level: 'error', message: [new Error(testErrorStr)] },
+      { level: 'debug', message: ['Should retry: true'] },
+      { level: 'error', message: [testError] },
+      { level: 'debug', message: ['Should retry: true'] }
+    ]);
   });
 
   it('polls the provider until the pollUntil condition is satisfied', async () => {
@@ -97,7 +97,6 @@ describe('coldObservableProvider', () => {
       .mockResolvedValueOnce('c')
       .mockResolvedValue('Never reached');
     const backoffConfig: RetryBackoffConfig = { initialInterval: 1 };
-    const logger = createMockLogger();
 
     const provider$ = coldObservableProvider({
       logger,
@@ -113,12 +112,11 @@ describe('coldObservableProvider', () => {
   });
 
   it('stops retrying after maxRetries attempts and handles the error in catchError', async () => {
-    const testError = new Error('Test error');
+    const testError = new Error(testErrorStr);
     const underlyingProvider = jest.fn().mockRejectedValue(testError);
     const maxRetries = 3;
     const retryBackoffConfig: RetryBackoffConfig = { initialInterval: 1, maxRetries };
     const onFatalError = jest.fn();
-    const logger = createMockLogger();
 
     const provider$ = coldObservableProvider({
       logger,
@@ -131,7 +129,10 @@ describe('coldObservableProvider', () => {
 
     expect(underlyingProvider).toBeCalledTimes(maxRetries + 1);
     expect(onFatalError).toBeCalledWith(expect.any(Error));
-    expect(logger.error).toHaveBeenCalled();
-    expect(logger.error).toHaveBeenCalledWith(testError);
+    expect(logger.messages).toStrictEqual([
+      { level: 'error', message: [testError] },
+      { level: 'error', message: [testError] },
+      { level: 'error', message: [testError] }
+    ]);
   });
 });