kempo 1.0.0

package/test/tests/utils/cli.test.js

@@ -0,0 +1,113 @@
+import cli from '../../kempo/utils/cli.js';
+
+export const name = 'CLI Tests';
+export const description = 'The CLI function returns an object that contains the key-value pairs of command line arguments passed into the scripts, it supports short codes and flags (they will simply have a true value).';
+
+export const tests = [
+  {
+    name: 'Get Arguments',
+    description: 'Does the function property return the arguments?',
+    test: ({
+      pass,
+      fail,
+      log
+    }) => {
+      window.global = window;
+      window.process = window.process || {};
+      window.process.argv = [
+        'node',
+        'scriptname',
+        '--arg1',
+        'val1',
+        '--arg2',
+        'val2'
+      ];
+      log(`Setting process.argv to ${JSON.stringify(process.argv)}`);
+      log('Running cli() to build these arguments into an object');
+      const results = cli();
+      const serialized = JSON.stringify(results);
+      log(`results = ${serialized}`);
+      if(serialized === `{"arg1":"val1","arg2":"val2"}`){
+        pass('The arguments were successfully parsed');
+      } else {
+        fail(
+          'Expected: {"arg1":"val1","arg2":"val2"}',
+          `Recieved: ${serialized}`
+        );
+      }
+    }
+  },
+  {
+    name: 'Process Flags',
+    description: 'Does this function understand flags (argument without values)',
+    test: ({
+      pass,
+      fail,
+      log
+    }) => {
+      window.global = window;
+      window.process = window.process || {};
+      window.process.argv = [
+        'node',
+        'scriptname',
+        '--arg1',
+        'val1',
+        '--flag1',
+        '--arg2',
+        'val2',
+        '--flag2'
+      ];
+      log(`Setting process.argv to ${JSON.stringify(process.argv)}`);
+      log('Running cli() to build these arguments into an object');
+      const results = cli();
+      const serialized = JSON.stringify(results);
+      log(`results = ${serialized}`);
+      if(serialized === `{"arg1":"val1","flag1":true,"arg2":"val2","flag2":true}`){
+        pass('The arguments were successfully parsed');
+      } else {
+        fail(
+          'Expected: {"arg1":"val1","flag1":true,"arg2":"val2","flag2":true}',
+          `Recieved: ${serialized}`
+        );
+      }
+    }
+  },
+  {
+    name: 'Process Shorthand Args',
+    description: 'Does this function understand shorthands, args and flags',
+    test: ({
+      pass,
+      fail,
+      log
+    }) => {
+      window.global = window;
+      window.process = window.process || {};
+      window.process.argv = [
+        'node',
+        'scriptname',
+        '-a',
+        'val1',
+        '-b',
+        'val2',
+      ];
+      const shortMap = {
+        a: 'arg1',
+        b: 'arg2'
+      }
+      log(`Setting process.argv to ${JSON.stringify(process.argv)}`);
+      log(`Creating a shorthand argument map ${JSON.stringify(shortMap)}`)
+      log('Running cli(shortMap) to build these arguments into an object');
+      const results = cli(shortMap);
+      const serialized = JSON.stringify(results);
+      log(`results = ${serialized}`);
+      if(serialized === `{"arg1":"val1","arg2":"val2"}`){
+        pass('The arguments were successfully parsed');
+      } else {
+        fail(
+          'Expected: {"arg1":"val1","arg2":"val2"}',
+          `Recieved: ${serialized}`
+        );
+      }
+    }
+  }
+];

package/test/tests/utils/cookie.test.js

@@ -0,0 +1,87 @@
+import {
+  saveCookie,
+  getCookie,
+  deleteCookie
+} from '../../kempo/utils/cookie.js';
+
+export const name = 'Cookie Tests';
+export const description = 'Testing cookie utility functions in <code>/kempo/utils/cookie.js</code>';
+
+export const tests = [
+  {
+    name: 'saveCookie',
+    description: 'Save a cookie to the browser',
+    test: ({
+      pass,
+      fail,
+      log 
+    }) => {
+      const name = "test";
+      const expected = "test123";
+      log(`Using saveCookie to save the cookie ${name}="${expected}"`);
+      saveCookie(name, expected);
+      const recieved = document.cookie.split('; ').find(cookie => cookie.startsWith(`${name}=`)).split('=')[1];
+      log('Retrieving the value from the cookie, and comparing it to the expected value');
+      document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+      if(expected===recieved){
+        pass('The cookie was successfully saved with the correct value');
+      } else {
+        fail(
+          'The cookie was not saved with the correct value',
+          `Expected: ${expected}`,
+          `Recieved: ${recieved}`
+        );
+      }
+    }
+  },
+  {
+    name: 'getCookie',
+    description: 'Retrieve a cookie from the browser',
+    test: ({
+      pass,
+      fail,
+      log
+    }) => {
+      const name = 'test';
+      const expected = 'test123';
+      log('Manually setting a cookie');
+      document.cookie = `${name}=${expected}; expires='${new Date(Date.now()+60000).toUTCString()};path=/`;
+      log('Using getCookie to retrieve the value');
+      const recieved = getCookie(name);
+      document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+      if(expected === recieved){
+        pass('The cookie was successfully retrieved with the correct value');
+      } else {
+        fail(
+          'The cookie was not retrieved with the correct value',
+          `Expected: ${expected}`,
+          `Recieved: ${recieved}`
+        );
+      }
+
+    }
+  },
+  {
+    name: 'delete Cookie',
+    description: 'Delete a cookie from the browser',
+    test: ({
+      pass,
+      fail,
+      log
+    }) => {
+      const name = 'test';
+      const value = 'test123';
+      log('Setting cookie');
+      document.cookie = `${name}=${value}; expires='${new Date(Date.now()+60000).toUTCString()};path=/`;
+      log('Deleting cookie with deleteCookie');
+      deleteCookie(name);
+      log('Attempting to retrieve cookie');
+      const recieved = document.cookie.split('; ').find(cookie => cookie.startsWith(`${name}=`));
+      if(recieved){
+        fail(`A cookie was found with name "${name}" when it should have been deleted`, recieved);
+      } else {
+        pass('The cookie was successfully deleted');
+      }
+    }
+  }
+]

package/test/tests/utils/debounce.test.js

@@ -0,0 +1,71 @@
+import debounce from '../../../kempo/utils/debounce.js';
+
+const wait = ms => new Promise(r=>setTimeout(r,ms));
+
+export const name = 'Debounce Function Test';
+export const description = 'Testing debounce utility functions in <code>/kempo/utils/debounce.js</code>';
+
+export const tests = [
+  {
+    name: 'Call Twice, Execute Once',
+    description: 'The debounced function will be called twice within the timeout and should only be executed once',
+    test: async ({
+      pass,
+      fail,
+      log 
+    }) => {
+      log('Creating a call counter');
+      let callCount = 0;
+      log('Creating a debounced function that incraments the counter when exectured, with a debounce timeout of 100ms');
+      const func = debounce(()=>{
+        log(`debounced function executed, incrament counter to ${++callCount}`);
+      }, 100);
+      log('Waiting 10ms');
+      await wait(10);
+      log('Calling the debounced function');
+      func();
+      log('Waiting 50ms');
+      await wait(50);
+      log('Calling the debounced function');
+      func();
+      log('Waiting 200ms before checking the counter');
+      await wait(200);
+      log('Checking the counter');
+      if(callCount === 1){
+        pass('The debounced function was executed once as expected');
+      } else {
+        fail(`The debounced function should have been executed once, but was executed ${callCount} times`);
+      }
+    }
+  },
+  {
+    name: 'Call Twice, Execure Twice',
+    description: 'The debounced function will be called twice, but with long enough between calls that both should execute',
+    test: async ({
+      pass,
+      fail,
+      log
+    }) => {
+      log('Creating a call counter');
+      let callCount = 0;
+      log('Creating a debounced function that incraments the counter when exectured, with a debounce timeout of 100ms');
+      const func = debounce(()=>{
+        log(`debounced function executed, incrament counter to ${++callCount}`);
+      }, 100);
+      log('Calling the debounced function');
+      func();
+      log('Waiting 101ms');
+      await wait(101);
+      log('Calling the debounced function');
+      func();
+      log('Waiting 200ms before checking the counter');
+      await wait(200);
+      log('Checking the counter');
+      if(callCount === 2){
+        pass('The debounced function was executed once as expected');
+      } else {
+        fail(`The debounced function should have been executed once, but was executed ${callCount} times`);
+      }
+    }
+  }
+]