test: Increase code coverage in package utils (#1093)

Closes #1089 

Increase code coverage in package utils.

Author: emilyhuxng

packages/utils/src/Asserts.test.ts

@@ -0,0 +1,5 @@
+import { assertNotNull } from './Asserts';
+
+it('throws an error when a value is null', () => {
+  expect(() => assertNotNull(null)).toThrowError('Value is null or undefined');
+});

packages/utils/src/ClipboardUtils.test.ts

@@ -0,0 +1,58 @@
+import { copyToClipboard } from './ClipboardUtils';
+
+document.execCommand = jest.fn();
+
+describe('Clipboard', () => {
+  describe('writeText', () => {
+    beforeEach(() => jest.resetAllMocks());
+
+    it('should call clipboard.writeText', async () => {
+      Object.assign(navigator, {
+        clipboard: {
+          // eslint-disable-next-line @typescript-eslint/no-empty-function
+          writeText: () => {},
+        },
+      });
+      jest.spyOn(navigator.clipboard, 'writeText');
+
+      await copyToClipboard('test');
+      expect(navigator.clipboard.writeText).toHaveBeenCalledWith('test');
+    });
+
+    it('should call copyToClipboardExecCommand if writeText fails', async () => {
+      Object.assign(navigator, {
+        clipboard: {
+          writeText: () => {
+            throw new Error('Could not write text');
+          },
+        },
+      });
+      document.execCommand = jest.fn(() => true);
+      jest.spyOn(navigator.clipboard, 'writeText');
+
+      await expect(copyToClipboard('test')).resolves.toBeUndefined();
+      expect(document.execCommand).toHaveBeenCalledWith('copy');
+    });
+
+    it('calls copyToClipboardExecCommand if clipboard is undefined and throws', async () => {
+      Object.assign(navigator, {
+        clipboard: undefined,
+      });
+      document.execCommand = jest.fn(() => false);
+
+      await expect(copyToClipboard('test')).rejects.toThrowError(
+        'Unable to execute copy command'
+      );
+    });
+
+    it('calls copyToClipboardExecCommand if clipboard is undefined but does not throw', async () => {
+      Object.assign(navigator, {
+        clipboard: undefined,
+      });
+      document.execCommand = jest.fn(() => true);
+
+      await expect(copyToClipboard('test')).resolves.toBeUndefined();
+      await expect(document.execCommand).toHaveBeenCalledWith('copy');
+    });
+  });
+});

packages/utils/src/ColorUtils.test.ts

@@ -0,0 +1,23 @@
+import ColorUtils from './ColorUtils';
+
+describe('isDark', () => {
+  it('returns true if the background is dark', () => {
+    expect(ColorUtils.isDark('#000000')).toBe(true);
+    expect(ColorUtils.isDark('#000')).toBe(true);
+    expect(ColorUtils.isDark('rgb(0,0,0)')).toBe(true);
+    expect(ColorUtils.isDark('rgba(0,0,0,1)')).toBe(true);
+    expect(ColorUtils.isDark('hsl(0,0%,0%)')).toBe(true);
+  });
+
+  it('returns false if the background is bright', () => {
+    expect(ColorUtils.isDark('#ffffff')).toBe(false);
+    expect(ColorUtils.isDark('#fff')).toBe(false);
+    expect(ColorUtils.isDark('rgb(255,255,255)')).toBe(false);
+    expect(ColorUtils.isDark('rgba(255,255,255,1)')).toBe(false);
+    expect(ColorUtils.isDark('hsl(0,100%,100%)')).toBe(false);
+  });
+
+  it('throws an error if the color is not a valid value', () => {
+    expect(() => ColorUtils.isDark('')).toThrowError(/Invalid color received/);
+  });
+});

packages/utils/src/EventTargetShimUtils.test.ts

@@ -0,0 +1,6 @@
+import { EventShimCustomEvent } from './EventTargetShimUtils';
+
+it('should create an EventShimCustomEvent', () => {
+  const event = new EventShimCustomEvent('test');
+  expect(event.type).toBe('test');
+});

packages/utils/src/InvalidMetadataError.test.ts

@@ -0,0 +1,6 @@
+import InvalidMetadataError from './InvalidMetadataError';
+
+it('should create an InvalidMetadataError object', () => {
+  const error = new InvalidMetadataError();
+  expect(error.isInvalidMetadata).toBe(true);
+});

packages/utils/src/PromiseUtils.test.ts

@@ -1,12 +1,40 @@
+import CanceledPromiseError from './CanceledPromiseError';
 import { PromiseUtils } from './PromiseUtils';
+import TimeoutError from './TimeoutError';
 
-it('wraps promises properly', () => {
-  const makeCancelable = () => {
-    // Need to add a catch block or the tests crash.
-    // https://github.com/facebook/jest/issues/5311
-    const cancelable = PromiseUtils.makeCancelable(null);
-    return cancelable;
-  };
+describe('makeCancelable', () => {
+  it('wraps promises properly', () => {
+    const makeCancelable = () => {
+      // Need to add a catch block or the tests crash.
+      // https://github.com/facebook/jest/issues/5311
+      const cancelable = PromiseUtils.makeCancelable(null);
+      return cancelable;
+    };
 
-  expect(typeof makeCancelable().cancel).toEqual('function');
+    expect(typeof makeCancelable().cancel).toEqual('function');
+  });
+});
+
+describe('isCanceled', () => {
+  it('returns true if the error is a CanceledPromiseError', () => {
+    const error = new CanceledPromiseError();
+    expect(PromiseUtils.isCanceled(error)).toBe(true);
+  });
+
+  it('returns false if the error is not a CanceledPromiseError', () => {
+    const error = new Error();
+    expect(PromiseUtils.isCanceled(error)).toBe(false);
+  });
+});
+
+describe('isTimedOut', () => {
+  it('returns true if the error is a TimeoutError', () => {
+    const error = new TimeoutError();
+    expect(PromiseUtils.isTimedOut(error)).toBe(true);
+  });
+
+  it('returns false if the error is not a TimeoutError', () => {
+    const error = new Error();
+    expect(PromiseUtils.isTimedOut(error)).toBe(false);
+  });
 });

packages/utils/src/RangeUtils.test.ts

@@ -23,3 +23,164 @@ describe('getItemsInRanges', () => {
     ).toEqual([1, 3, 4]);
   });
 });
+
+describe('isValidRange', () => {
+  it('returns true if the range is valid', () => {
+    expect(RangeUtils.isValidRange([0, 10])).toBe(true);
+  });
+
+  it('returns false if the range is invalid', () => {
+    expect(RangeUtils.isValidRange([10, 0])).toBe(false);
+  });
+});
+
+describe('validateRange', () => {
+  it('throws an error if a range is invalid', () => {
+    expect(() => RangeUtils.validateRange([10, 0])).toThrowError(
+      'Invalid range! 10,0'
+    );
+  });
+});
+
+describe('isSelected', () => {
+  it('returns true if the index is within the selected ranges', () => {
+    expect(
+      RangeUtils.isSelected(
+        [
+          [0, 2],
+          [3, 4],
+        ],
+        1
+      )
+    ).toBe(true);
+  });
+
+  it('returns false if the index is not within one of the selected ranges', () => {
+    expect(
+      RangeUtils.isSelected(
+        [
+          [0, 2],
+          [3, 4],
+        ],
+        5
+      )
+    ).toBe(false);
+  });
+});
+
+describe('selectRange', () => {
+  it('returns the same selected ranges if the given range is already within a range', () => {
+    expect(
+      RangeUtils.selectRange(
+        [
+          [0, 2],
+          [3, 4],
+          [5, 7],
+        ],
+        [0, 1]
+      )
+    ).toEqual([
+      [0, 2],
+      [3, 4],
+      [5, 7],
+    ]);
+  });
+
+  it('consolidates the previous ranges if they overlap', () => {
+    expect(
+      RangeUtils.selectRange(
+        [
+          [50, 60],
+          [10, 20],
+          [30, 40],
+        ],
+        [15, 35]
+      )
+    ).toEqual([
+      [50, 60],
+      [10, 40],
+    ]);
+  });
+});
+
+describe('deselectRanges', () => {
+  it('returns the same selected ranges if the given range is not selected', () => {
+    expect(
+      RangeUtils.deselectRange(
+        [
+          [50, 60],
+          [10, 20],
+          [30, 40],
+        ],
+        [0, 1]
+      )
+    ).toEqual([
+      [50, 60],
+      [10, 20],
+      [30, 40],
+    ]);
+  });
+
+  it('splits a range if the given range is fully contained within another range', () => {
+    expect(
+      RangeUtils.deselectRange(
+        [
+          [50, 60],
+          [10, 20],
+          [30, 40],
+        ],
+        [55, 57]
+      )
+    ).toEqual([
+      [50, 54],
+      [58, 60],
+      [10, 20],
+      [30, 40],
+    ]);
+  });
+
+  it('removes a range if the given range fully engulfs the range', () => {
+    expect(
+      RangeUtils.deselectRange(
+        [
+          [50, 60],
+          [10, 20],
+          [30, 40],
+        ],
+        [5, 25]
+      )
+    ).toEqual([
+      [50, 60],
+      [30, 40],
+    ]);
+  });
+
+  it('trims a range if the given range overlaps the start or end of a range', () => {
+    expect(
+      RangeUtils.deselectRange(
+        [
+          [50, 60],
+          [10, 20],
+          [30, 40],
+        ],
+        [15, 35]
+      )
+    ).toEqual([
+      [50, 60],
+      [10, 14],
+      [36, 40],
+    ]);
+  });
+});
+
+describe('count', () => {
+  it('should return the total number of items in the given ranges', () => {
+    expect(
+      RangeUtils.count([
+        [50, 60],
+        [10, 20],
+        [30, 40],
+      ])
+    ).toEqual(33);
+  });
+});