dce-reactkit 3.4.0-beta.8 → 3.4.0

package/src/helpers/canReviewLogs.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Unit tests for canReviewLogs
+ * @author Gabe Abrams
+ */
+
+// Import dce-reactkit
+import stubServerEndpoint from './stubServerEndpoint';
+
+// Import main function
+import canReviewLogs, { resetCanReviewCache } from './canReviewLogs';
+
+// Import shared constants
+import LOG_REVIEW_STATUS_ROUTE from '../constants/LOG_REVIEW_STATUS_ROUTE';
+
+describe('helpers > canReviewLogs', () => {
+  beforeEach(() => {
+    // Reset the cache
+    resetCanReviewCache();
+  });
+
+  it('should return true if the server returns a truthy value', async () => {
+    stubServerEndpoint({
+      method: 'GET',
+      path: LOG_REVIEW_STATUS_ROUTE,
+      body: true,
+    });
+
+    const result = await canReviewLogs();
+    expect(result).toEqual(true);
+  });
+
+  it('should return false if the server returns a falsy value', async () => {
+    stubServerEndpoint({
+      method: 'GET',
+      path: LOG_REVIEW_STATUS_ROUTE,
+      body: false,
+    });
+
+    const result = await canReviewLogs();
+    expect(result).toEqual(false);
+  });
+
+  it('should return false if the server throws an error', async () => {
+    stubServerEndpoint({
+      method: 'GET',
+      path: LOG_REVIEW_STATUS_ROUTE,
+      errorMessage: 'Server error',
+      errorCode: 'C500',
+    });
+
+    const result = await canReviewLogs();
+    expect(result).toEqual(false);
+  });
+
+  it('should cache the server response and return it on subsequent calls', async () => {
+    stubServerEndpoint({
+      method: 'GET',
+      path: LOG_REVIEW_STATUS_ROUTE,
+      body: true,
+    });
+
+    const result1 = await canReviewLogs();
+    const result2 = await canReviewLogs();
+    expect(result1).toEqual(true);
+    expect(result2).toEqual(true);
+  });
+});

package/src/helpers/canReviewLogs.ts

@@ -4,9 +4,29 @@ import visitServerEndpoint from './visitServerEndpoint';
 // Import shared constants
 import LOG_REVIEW_STATUS_ROUTE from '../constants/LOG_REVIEW_STATUS_ROUTE';
 
+/*------------------------------------------------------------------------*/
+/* -------------------------------- Cache ------------------------------- */
+/*------------------------------------------------------------------------*/
+
 // Cache user's ability
 let canReview: boolean | undefined = undefined;
 
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Other Helpers --------------------------- */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Reset the cached version of canReview
+ * @author Gabe Abrams
+ */
+export const resetCanReviewCache = () => {
+  canReview = undefined;
+};
+
+/*------------------------------------------------------------------------*/
+/* -------------------------------- Main -------------------------------- */
+/*------------------------------------------------------------------------*/
+
 /**
  * Check if the current user can review logs
  * @author Gabe Abrams

package/src/helpers/ceilToNumDecimals.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Test file for the ceilToNumDecimals helper
+ * @author Gabe Abrams
+ */
+
+// Import main function
+import ceilToNumDecimals from './ceilToNumDecimals';
+
+describe('ceilToNumDecimals', () => {
+  it('should return 0 for 0 with 0 decimals', () => {
+    const result = ceilToNumDecimals(0, 0);
+    expect(result).toEqual(0);
+  });
+
+  it('should return 1 for 1 with 0 decimals', () => {
+    const result = ceilToNumDecimals(1, 0);
+    expect(result).toEqual(1);
+  });
+
+  it('should return 1.24 for 1.234 with 2 decimals', () => {
+    const result = ceilToNumDecimals(1.234, 2);
+    expect(result).toEqual(1.24);
+  });
+
+  it('should return -1.23 for -1.234 with 2 decimals', () => {
+    const result = ceilToNumDecimals(-1.234, 2);
+    expect(result).toEqual(-1.23);
+  });
+
+  it('should return 1234 for 1234 with 0 decimals', () => {
+    const result = ceilToNumDecimals(1234, 0);
+    expect(result).toEqual(1234);
+  });
+
+  it('should return 0.002 for 0.00123 with 3 decimals', () => {
+    const result = ceilToNumDecimals(0.00123, 3);
+    expect(result).toEqual(0.002);
+  });
+});

package/src/helpers/compareArraysByProp.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Test file for the compareArraysByProp helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import compareArraysByProp from './compareArraysByProp';
+
+describe('compareArraysByProp', () => {
+  it('should return true for two empty arrays', () => {
+    const result = compareArraysByProp([], [], 'id');
+    expect(result).toEqual(true);
+  });
+
+  it('should return true for two arrays with the same objects in the same order', () => {
+    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+    const b = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(true);
+  });
+
+  it('should return true for two arrays with the same objects in a different order', () => {
+    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+    const b = [{ id: 3, name: 'Charlie' }, { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(true);
+  });
+
+  it('should return false for two arrays with different objects', () => {
+    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+    const b = [{ id: 4, name: 'Dave' }, { id: 5, name: 'Eve' }, { id: 6, name: 'Frank' }];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for two arrays with different objects and some shared objects', () => {
+    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+    const b = [{ id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }, { id: 4, name: 'Dave' }];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(false);
+  });
+
+  it('should return true for two arrays with the same objects with multiple properties', () => {
+    const a = [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+    ];
+    const b = [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+    ];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(true);
+  });
+
+  it('should return true for two arrays with the same objects with multiple properties in a different order', () => {
+    const a = [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+    ];
+    const b = [
+      { id: 3, name: 'Charlie', age: 35 },
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+    ];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(true);
+  });
+
+  it('should return false for two arrays with different objects with multiple properties', () => {
+    const a = [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+    ];
+    const b = [
+      { id: 4, name: 'Dave', age: 40 },
+      { id: 5, name: 'Eve', age: 45 },
+      { id: 6, name: 'Frank', age: 50 },
+    ];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for two arrays with different objects with multiple properties and some shared objects', () => {
+    const a = [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+    ];
+    const b = [
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 },
+      { id: 4, name: 'Dave', age: 40 },
+    ];
+    const result = compareArraysByProp(a, b, 'id');
+    expect(result).toEqual(false);
+  });
+});

package/src/helpers/extractProp.test.ts

@@ -0,0 +1,34 @@
+/**
+ * Test file for the extractProp helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import extractProp from './extractProp';
+
+describe('extractProp', () => {
+  it('should return an empty array if the input array is empty', () => {
+    const result = extractProp([], 'age');
+    expect(result).toEqual([]);
+  });
+
+  it('should extract the correct property from each object in the array', () => {
+    const users = [
+      { name: 'Alice', age: 25 },
+      { name: 'Bob', age: 30 },
+      { name: 'Charlie', age: 35 },
+    ];
+    const result = extractProp(users, 'age');
+    expect(result).toEqual([25, 30, 35]);
+  });
+
+  it('should return undefined for objects that do not have the specified property', () => {
+    const users = [
+      { name: 'Alice', age: 25 },
+      { name: 'Bob' },
+      { name: 'Charlie', age: 35 },
+    ];
+    const result = extractProp(users, 'age');
+    expect(result).toEqual([25, undefined, 35]);
+  });
+});

package/src/helpers/floorToNumDecimals.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Test file for the floorToNumDecimals helper
+ * @author Gabe Abrams
+ */
+
+// Import main function
+import floorToNumDecimals from './floorToNumDecimals';
+
+describe('floorToNumDecimals', () => {
+  it('should return 0 for 0 with 0 decimals', () => {
+    const result = floorToNumDecimals(0, 0);
+    expect(result).toEqual(0);
+  });
+
+  it('should return 1 for 1 with 0 decimals', () => {
+    const result = floorToNumDecimals(1, 0);
+    expect(result).toEqual(1);
+  });
+
+  it('should return 1.23 for 1.234 with 2 decimals', () => {
+    const result = floorToNumDecimals(1.234, 2);
+    expect(result).toEqual(1.23);
+  });
+
+  it('should return -1.24 for -1.234 with 2 decimals', () => {
+    const result = floorToNumDecimals(-1.234, 2);
+    expect(result).toEqual(-1.24);
+  });
+
+  it('should return 1234 for 1234 with 0 decimals', () => {
+    const result = floorToNumDecimals(1234, 0);
+    expect(result).toEqual(1234);
+  });
+
+  it('should return 0.001 for 0.00123 with 3 decimals', () => {
+    const result = floorToNumDecimals(0.00123, 3);
+    expect(result).toEqual(0.001);
+  });
+});

package/src/helpers/forceNumIntoBounds.test.ts

@@ -0,0 +1,34 @@
+/**
+ * Test file for the forceNumIntoBounds helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import forceNumIntoBounds from './forceNumIntoBounds';
+
+describe('forceNumIntoBounds', () => {
+  it('should return the number if it is within the bounds', () => {
+    const result = forceNumIntoBounds(5, 0, 10);
+    expect(result).toEqual(5);
+  });
+
+  it('should return the minimum bound if the number is less than the minimum', () => {
+    const result = forceNumIntoBounds(-5, 0, 10);
+    expect(result).toEqual(0);
+  });
+
+  it('should return the maximum bound if the number is greater than the maximum', () => {
+    const result = forceNumIntoBounds(15, 0, 10);
+    expect(result).toEqual(10);
+  });
+
+  it('should return the minimum bound if the number is equal to the minimum', () => {
+    const result = forceNumIntoBounds(0, 0, 10);
+    expect(result).toEqual(0);
+  });
+
+  it('should return the maximum bound if the number is equal to the maximum', () => {
+    const result = forceNumIntoBounds(10, 0, 10);
+    expect(result).toEqual(10);
+  });
+});

package/src/helpers/genCSV.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Test file for the genCSV helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import genCSV from './genCSV';
+
+describe('genCSV', () => {
+  it('should return an empty string for empty data', () => {
+    const result = genCSV([], []);
+    expect(result).toEqual('');
+  });
+
+  it('should generate a CSV with the correct headers and data', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Age', param: 'age' },
+      { title: 'Email', param: 'email' },
+    ];
+    const data = [
+      { name: 'Alice', age: 25, email: 'alice@example.com' },
+      { name: 'Bob', age: 30, email: 'bob@example.com' },
+      { name: 'Charlie', age: 35, email: 'charlie@example.com' },
+    ];
+    const expected = `Name,Age,Email\nAlice,25,alice@example.com\nBob,30,bob@example.com\nCharlie,35,charlie@example.com`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle undefined and null values correctly', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Age', param: 'age' },
+      { title: 'Email', param: 'email' },
+    ];
+    const data = [
+      { name: 'Alice', age: undefined, email: null },
+      { name: 'Bob', age: null, email: 'bob@example.com' },
+      { name: 'Charlie', age: 35, email: undefined },
+    ];
+    const expected = `Name,Age,Email\nAlice,,\nBob,,bob@example.com\nCharlie,35,`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle objects in cells correctly', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Data', param: 'data' },
+    ];
+    const data = [
+      { name: 'Alice', data: { foo: 'bar' } },
+      { name: 'Bob', data: [1, 2, 3] },
+      { name: 'Charlie', data: null },
+    ];
+    const expected = `Name,Data\nAlice,"{""foo"":""bar""}"\nBob,"[1,2,3]"\nCharlie,`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+});

package/src/helpers/genCSV.ts

@@ -5,13 +5,16 @@
  * @returns escaped cell text
  */
 const escapeCellText = (text: string): string => {
-  if (!String(text).includes(',')) {
+  if (
+    !String(text).includes(',')
+    && !String(text).includes('"')
+  ) {
     // No need to escape
     return String(text);
   }
 
   // Perform escape
-  return `"${String(text).replace(/"/g, '""')}`;
+  return `"${String(text).replace(/"/g, '""')}"`;
 };
 
 /**

package/src/helpers/genCommaList.test.ts

@@ -0,0 +1,57 @@
+// Import function
+import genCommaList from './genCommaList';
+
+test(
+  'Empty list.',
+  async () => {
+    const emptyList: string[] = [];
+    const emptyListResponse: string = '';
+
+    const result = genCommaList(emptyList);
+    expect(result).toStrictEqual(emptyListResponse);
+  },
+);
+
+test(
+  'One word list.',
+  async () => {
+    const oneList: string[] = ['apples'];
+    const oneListResponse: string = 'apples';
+
+    const result = genCommaList(oneList);
+    expect(result).toStrictEqual(oneListResponse);
+  },
+);
+
+test(
+  'Two word list.',
+  async () => {
+    const twoList: string[] = ['apples', 'oranges'];
+    const twoListResponse: string = 'apples and oranges';
+
+    const result = genCommaList(twoList);
+    expect(result).toStrictEqual(twoListResponse);
+  },
+);
+
+test(
+  'Three word list.',
+  async () => {
+    const threeList: string[] = ['apples', 'oranges', 'bananas'];
+    const threeListResponse: string = 'apples, oranges, and bananas';
+
+    const result = genCommaList(threeList);
+    expect(result).toStrictEqual(threeListResponse);
+  },
+);
+
+test(
+  'Four word list.',
+  async () => {
+    const fourList: string[] = ['apples', 'oranges', 'bananas', 'grapes'];
+    const fourListResponse: string = 'apples, oranges, bananas, and grapes';
+
+    const result = genCommaList(fourList);
+    expect(result).toStrictEqual(fourListResponse);
+  },
+);

package/src/helpers/genCommaList.ts

@@ -0,0 +1,21 @@
+/**
+ * Given an array of strings, create a single comma-separated string that includes
+ * 'and' as well as an oxford comma.
+ *   Ex: ['apples'] => 'apples'
+ *   Ex: ['apples', 'bananas'] => 'apples and bananas'
+ *   Ex: ['apples', 'bananas', 'grapes'] => 'apples, bananas, and grapes'
+ * @author Austen Money
+ * @param list an array of elements to be made into a single comma-separated string.
+ * @returns a comma-separated string.
+ */
+const genCommaList = (list: string[]): string => {
+  const { length } = list;
+
+  return (
+    length < 2
+      ? list.join('')
+      : `${list.slice(0, length - 1).join(', ')}${length < 3 ? ' and ' : ', and '}${list[length - 1]}`
+  );
+};
+
+export default genCommaList;

package/src/helpers/getHumanReadableDate.test.ts

@@ -0,0 +1,29 @@
+/**
+ * Test file for the getHumanReadableDate helper
+ * @author Gabe Abrams
+ */
+
+// Import helpers
+import getHumanReadableDate from './getHumanReadableDate';
+import getOrdinal from './getOrdinal';
+
+describe('getHumanReadableDate', () => {
+  it('should return the current date if no argument is passed', () => {
+    const result = getHumanReadableDate();
+    const now = new Date();
+    const expected = `${now.toLocaleString('default', { month: 'short' })} ${now.getDate()}${getOrdinal(now.getDate())}`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should return the correct date for a given timestamp', () => {
+    const timestamp = 1629822000000; // 2021-08-24T12:20:00.000Z
+    const result = getHumanReadableDate(timestamp);
+    expect(result).toEqual('Aug 24th 2021');
+  });
+
+  it('should return the correct date for a given Date object', () => {
+    const date = new Date('2021-08-24T12:20:00.000Z');
+    const result = getHumanReadableDate(date);
+    expect(result).toEqual('Aug 24th 2021');
+  });
+});

package/src/helpers/getLocalTimeInfo.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Test for getLocalTimeInfo helper function
+ *   NOTE: only works if this test is run on a machine in ET
+ * @author Gabe Abrams
+ */
+
+// Import main function
+import getLocalTimeInfo from './getLocalTimeInfo';
+
+describe('getLocalTimeInfo', () => {
+  it('should return current time info if no argument is passed', () => {
+    const result = getLocalTimeInfo();
+    const now = new Date();
+    expect(result.timestamp).toBeCloseTo(now.getTime(), -3);
+    expect(result.year).toEqual(now.getFullYear());
+    expect(result.month).toEqual(now.getMonth() + 1);
+    expect(result.day).toEqual(now.getDate());
+    expect(result.hour).toEqual(now.getHours());
+    expect(result.minute).toEqual(now.getMinutes());
+    expect(result.isPM).toEqual(now.getHours() >= 12);
+  });
+
+  it('should return correct time info for a given timestamp', () => {
+    const timestamp = 1629822000000; // 2021-08-24T12:20:00.000Z
+    const result = getLocalTimeInfo(timestamp);
+    expect(result.timestamp).toEqual(timestamp);
+    expect(result.year).toEqual(2021);
+    expect(result.month).toEqual(8);
+    expect(result.day).toEqual(24);
+    expect(result.hour).toEqual(12);
+    expect(result.hour12).toEqual(12);
+    expect(result.minute).toEqual(20);
+    expect(result.isPM).toEqual(true);
+  });
+
+  it('should return correct time info for a given Date object', () => {
+    const date = new Date('2021-08-24T12:20:00.000Z');
+    const result = getLocalTimeInfo(date);
+    expect(result.timestamp).toEqual(date.getTime());
+    expect(result.year).toEqual(2021);
+    expect(result.month).toEqual(8);
+    expect(result.day).toEqual(24);
+    expect(result.hour).toEqual(8);
+    expect(result.hour12).toEqual(8);
+    expect(result.minute).toEqual(20);
+    expect(result.isPM).toEqual(false);
+  });
+});

package/src/helpers/getMonthName.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Test for getMonthName helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import getMonthName from './getMonthName';
+
+describe('getMonthName', () => {
+  it('should return January for 1', () => {
+    const result = getMonthName(1);
+    expect(result).toEqual({ short: 'Jan', full: 'January' });
+  });
+
+  it('should return February for 2', () => {
+    const result = getMonthName(2);
+    expect(result).toEqual({ short: 'Feb', full: 'February' });
+  });
+
+  it('should return March for 3', () => {
+    const result = getMonthName(3);
+    expect(result).toEqual({ short: 'Mar', full: 'March' });
+  });
+
+  it('should return April for 4', () => {
+    const result = getMonthName(4);
+    expect(result).toEqual({ short: 'Apr', full: 'April' });
+  });
+
+  it('should return May for 5', () => {
+    const result = getMonthName(5);
+    expect(result).toEqual({ short: 'May', full: 'May' });
+  });
+
+  it('should return June for 6', () => {
+    const result = getMonthName(6);
+    expect(result).toEqual({ short: 'Jun', full: 'June' });
+  });
+
+  it('should return July for 7', () => {
+    const result = getMonthName(7);
+    expect(result).toEqual({ short: 'Jul', full: 'July' });
+  });
+
+  it('should return August for 8', () => {
+    const result = getMonthName(8);
+    expect(result).toEqual({ short: 'Aug', full: 'August' });
+  });
+
+  it('should return September for 9', () => {
+    const result = getMonthName(9);
+    expect(result).toEqual({ short: 'Sep', full: 'September' });
+  });
+
+  it('should return October for 10', () => {
+    const result = getMonthName(10);
+    expect(result).toEqual({ short: 'Oct', full: 'October' });
+  });
+
+  it('should return November for 11', () => {
+    const result = getMonthName(11);
+    expect(result).toEqual({ short: 'Nov', full: 'November' });
+  });
+
+  it('should return December for 12', () => {
+    const result = getMonthName(12);
+    expect(result).toEqual({ short: 'Dec', full: 'December' });
+  });
+
+  it('should return January for 0', () => {
+    const result = getMonthName(0);
+    expect(result).toEqual({ short: 'Jan', full: 'January' });
+  });
+
+  it('should return January for 13', () => {
+    const result = getMonthName(13);
+    expect(result).toEqual({ short: 'Jan', full: 'January' });
+  });
+});