chore(shared): Improve test coverage

.changeset/grumpy-swans-taste.md

@@ -0,0 +1,5 @@
+---
+"@clerk/shared": patch
+---
+
+Improve internal test coverage and fix small bug inside `callWithRetry`

packages/shared/src/__tests__/browser.test.ts

@@ -1,9 +1,66 @@
-import { inBrowser, isValidBrowserOnline, userAgentIsRobot } from '../browser';
+import { inBrowser, isValidBrowser, isValidBrowserOnline, userAgentIsRobot } from '../browser';
 
 describe('inBrowser()', () => {
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
  it('returns true if window is defined', () => {
  expect(inBrowser()).toBe(true);
  });
+ it('returns false if window is undefined', () => {
+ const windowSpy = jest.spyOn(global, 'window', 'get');
+ // @ts-ignore - Test
+ windowSpy.mockReturnValue(undefined);
+ expect(inBrowser()).toBe(false);
+ });
+});
+
+describe('isValidBrowser', () => {
+ let userAgentGetter: any;
+ let webdriverGetter: any;
+
+ beforeEach(() => {
+ userAgentGetter = jest.spyOn(window.navigator, 'userAgent', 'get');
+ webdriverGetter = jest.spyOn(window.navigator, 'webdriver', 'get');
+ });
+
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
+ it('returns false if not in browser', () => {
+ const windowSpy = jest.spyOn(global, 'window', 'get');
+ // @ts-ignore - Test
+ windowSpy.mockReturnValue(undefined);
+
+ expect(isValidBrowser()).toBe(false);
+ });
+
+ it('returns true if in browser, navigator is not a bot, and webdriver is not enabled', () => {
+ userAgentGetter.mockReturnValue(
+ 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0',
+ );
+ webdriverGetter.mockReturnValue(false);
+
+ expect(isValidBrowser()).toBe(true);
+ });
+
+ it('returns false if navigator is a bot', () => {
+ userAgentGetter.mockReturnValue('msnbot-NewsBlogs/2.0b (+http://search.msn.com/msnbot.htm)');
+ webdriverGetter.mockReturnValue(false);
+
+ expect(isValidBrowser()).toBe(false);
+ });
+
+ it('returns false if webdriver is enabled', () => {
+ userAgentGetter.mockReturnValue(
+ 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0',
+ );
+ webdriverGetter.mockReturnValue(true);
+
+ expect(isValidBrowser()).toBe(false);
+ });
 });
 
 describe('detectUserAgentRobot', () => {

packages/shared/src/__tests__/callWithRetry.test.ts

@@ -0,0 +1,23 @@
+import { callWithRetry } from '../callWithRetry';
+
+describe('callWithRetry', () => {
+ test('should return the result of the function if it succeeds', async () => {
+ const fn = jest.fn().mockResolvedValue('result');
+ const result = await callWithRetry(fn);
+ expect(result).toBe('result');
+ expect(fn).toHaveBeenCalledTimes(1);
+ });
+
+ test('should retry the function if it fails', async () => {
+ const fn = jest.fn().mockRejectedValueOnce(new Error('error')).mockResolvedValueOnce('result');
+ const result = await callWithRetry(fn, 1, 2);
+ expect(result).toBe('result');
+ expect(fn).toHaveBeenCalledTimes(2);
+ });
+
+ test('should throw an error if the function fails too many times', async () => {
+ const fn = jest.fn().mockRejectedValue(new Error('error'));
+ await expect(callWithRetry(fn, 1, 2)).rejects.toThrow('error');
+ expect(fn).toHaveBeenCalledTimes(2);
+ });
+});

packages/shared/src/__tests__/keys.test.ts

@@ -1,7 +1,9 @@
 import {
  buildPublishableKey,
  createDevOrStagingUrlCache,
+ isDevelopmentFromApiKey,
  isLegacyFrontendApiKey,
+ isProductionFromApiKey,
  isPublishableKey,
  parsePublishableKey,
 } from '../keys';
@@ -90,3 +92,31 @@ describe('isDevOrStagingUrl(url)', () => {
  expect(isDevOrStagingUrl(a)).toBe(expected);
  });
 });
+
+describe('isDevelopmentFromApiKey(key)', () => {
+ const cases: Array<[string, boolean]> = [
+ ['sk_live_Y2xlcmsuY2xlcmsuZGV2JA==', false],
+ ['sk_test_Y2xlcmsuY2xlcmsuZGV2JA==', true],
+ ['live_Y2xlcmsuY2xlcmsuZGV2JA==', false],
+ ['test_Y2xlcmsuY2xlcmsuZGV2JA==', true],
+ ];
+
+ test.each(cases)('given %p as a publishable key string, returns %p', (publishableKeyStr, expected) => {
+ const result = isDevelopmentFromApiKey(publishableKeyStr);
+ expect(result).toEqual(expected);
+ });
+});
+
+describe('isProductionFromApiKey(key)', () => {
+ const cases: Array<[string, boolean]> = [
+ ['sk_live_Y2xlcmsuY2xlcmsuZGV2JA==', true],
+ ['sk_test_Y2xlcmsuY2xlcmsuZGV2JA==', false],
+ ['live_Y2xlcmsuY2xlcmsuZGV2JA==', true],
+ ['test_Y2xlcmsuY2xlcmsuZGV2JA==', false],
+ ];
+
+ test.each(cases)('given %p as a publishable key string, returns %p', (publishableKeyStr, expected) => {
+ const result = isProductionFromApiKey(publishableKeyStr);
+ expect(result).toEqual(expected);
+ });
+});

packages/shared/src/__tests__/url.test.ts

@@ -1,4 +1,4 @@
-import { addClerkPrefix, parseSearchParams, stripScheme } from '../url';
+import { addClerkPrefix, getClerkJsMajorVersionOrTag, getScriptUrl, parseSearchParams, stripScheme } from '../url';
 
 describe('parseSearchParams(queryString)', () => {
  it('parses query string and returns a URLSearchParams object', () => {
@@ -56,3 +56,59 @@ describe('addClerkPrefix(str)', () => {
  expect(addClerkPrefix(urlInput)).toBe(urlOutput);
  });
 });
+
+describe('getClerkJsMajorVersionOrTag', () => {
+ const stagingFrontendApi = 'foobar.lclstage.dev';
+
+ it('returns staging if pkgVersion is not provided and frontendApi is staging', () => {
+ expect(getClerkJsMajorVersionOrTag(stagingFrontendApi)).toBe('staging');
+ });
+
+ it('returns latest if pkgVersion is not provided and frontendApi is not staging', () => {
+ expect(getClerkJsMajorVersionOrTag('foobar.dev')).toBe('latest');
+ });
+
+ it('returns next if pkgVersion contains next', () => {
+ expect(getClerkJsMajorVersionOrTag('foobar.dev', '1.2.3-next.4')).toBe('next');
+ });
+
+ it('returns the major version if pkgVersion is provided', () => {
+ expect(getClerkJsMajorVersionOrTag('foobar.dev', '1.2.3')).toBe('1');
+ });
+
+ it('returns latest if pkgVersion is empty string', () => {
+ expect(getClerkJsMajorVersionOrTag('foobar.dev', '')).toBe('latest');
+ });
+});
+
+describe('getScriptUrl', () => {
+ const frontendApi = 'https://foobar.dev';
+
+ it('returns URL using the clerkJSVersion if provided', () => {
+ expect(getScriptUrl(frontendApi, { clerkJSVersion: '1.2.3' })).toBe(
+ 'https://foobar.dev/npm/@clerk/clerk-js@1.2.3/dist/clerk.browser.js',
+ );
+ });
+
+ it('returns URL using the latest version if clerkJSVersion & pkgVersion is not provided + frontendApi is not staging', () => {
+ expect(getScriptUrl(frontendApi, {})).toBe('https://foobar.dev/npm/@clerk/clerk-js@latest/dist/clerk.browser.js');
+ });
+
+ it('returns URL using the major version if only pkgVersion is provided', () => {
+ expect(getScriptUrl(frontendApi, { pkgVersion: '1.2.3' })).toBe(
+ 'https://foobar.dev/npm/@clerk/clerk-js@1/dist/clerk.browser.js',
+ );
+ });
+
+ it('returns URL using the major version if only pkgVersion contains next', () => {
+ expect(getScriptUrl(frontendApi, { pkgVersion: '1.2.3-next.4' })).toBe(
+ 'https://foobar.dev/npm/@clerk/clerk-js@next/dist/clerk.browser.js',
+ );
+ });
+
+ it('returns URL using the staging tag if frontendApi is staging', () => {
+ expect(getScriptUrl('https://foobar.lclstage.dev', {})).toBe(
+ 'https://foobar.lclstage.dev/npm/@clerk/clerk-js@staging/dist/clerk.browser.js',
+ );
+ });
+});

packages/shared/src/callWithRetry.ts

@@ -23,6 +23,6 @@ export async function callWithRetry<T>(
  }
  await wait(2 ** attempt * 100);
 
- return callWithRetry(fn, attempt + 1);
+ return callWithRetry(fn, attempt + 1, maxAttempts);
  }
 }

packages/shared/src/utils/__tests__/createDeferredPromise.test.ts

@@ -0,0 +1,22 @@
+import { createDeferredPromise } from '../createDeferredPromise';
+
+describe('createDeferredPromise', () => {
+ test('resolves with correct value', async () => {
+ const { promise, resolve } = createDeferredPromise();
+ const expectedValue = 'hello world';
+ resolve(expectedValue);
+ const result = await promise;
+ expect(result).toBe(expectedValue);
+ });
+
+ test('rejects with correct error', async () => {
+ const { promise, reject } = createDeferredPromise();
+ const expectedError = new Error('something went wrong');
+ reject(expectedError);
+ try {
+ await promise;
+ } catch (error) {
+ expect(error).toBe(expectedError);
+ }
+ });
+});

packages/shared/src/utils/__tests__/instance.test.ts

@@ -0,0 +1,20 @@
+import { isStaging } from '../instance';
+
+describe('isStaging', () => {
+ it.each([
+ ['clerk', false],
+ ['clerk.com', false],
+ ['whatever.com', false],
+ ['clerk.abcef', false],
+ ['clerk.abcef.12345', false],
+ ['clerk.abcef.12345.lcl', false],
+ ['clerk.abcef.12345.lcl.dev', false],
+ ['clerk.abcef.12345.stg.dev', false],
+ ['clerk.abcef.12345.lclstage.dev', true],
+ ['clerk.abcef.12345.stgstage.dev', true],
+ ['clerk.abcef.12345.clerkstage.dev', true],
+ ['clerk.abcef.12345.accountsstage.dev', true],
+ ])('validates the frontendApi format', (str, expected) => {
+ expect(isStaging(str)).toBe(expected);
+ });
+});

packages/shared/src/utils/__tests__/runWithExponentialBackOff.test.ts

@@ -0,0 +1,21 @@
+import { runWithExponentialBackOff } from '../runWithExponentialBackOff';
+
+describe('runWithExponentialBackOff', () => {
+ test('resolves with the result of the callback', async () => {
+ const result = await runWithExponentialBackOff(() => Promise.resolve('success'));
+ expect(result).toBe('success');
+ });
+
+ test('retries the callback until it succeeds', async () => {
+ let attempts = 0;
+ const result = await runWithExponentialBackOff(() => {
+ attempts++;
+ if (attempts < 3) {
+ throw new Error('failed');
+ }
+ return Promise.resolve('success');
+ });
+ expect(result).toBe('success');
+ expect(attempts).toBe(3);
+ });
+});

packages/shared/src/utils/instance.ts

@@ -1,3 +1,6 @@
+/**
+ * Check if the frontendApi ends with a staging domain
+ */
 export function isStaging(frontendApi: string): boolean {
  return (
  frontendApi.endsWith('.lclstage.dev') ||