chore: moved tests to ./test directory (#366)

* chore: allow coverage to be generated from non-tested files

5 files changed, 375 insertions, 0 deletions

diff --git a/test/features/utils/FeatureStore.test.js b/test/features/utils/FeatureStore.test.js
new file mode 100644
index 000000000..d8d85bec1
--- /dev/null
+++ b/test/features/utils/FeatureStore.test.js
@@ -0,0 +1,93 @@
+import PropTypes from 'prop-types';
+import { observable } from 'mobx';
+import { FeatureStore } from '../../../src/features/utils/FeatureStore';
+import { createActionsFromDefinitions } from '../../../src/actions/lib/actions';
+import { createActionBindings } from '../../../src/features/utils/ActionBinding';
+import { createReactions } from '../../../src/stores/lib/Reaction';
+
+const actions = createActionsFromDefinitions(
+  {
+    countUp: {},
+  },
+  PropTypes.checkPropTypes,
+);
+
+class TestFeatureStore extends FeatureStore {
+  @observable count = 0;
+
+  reactionInvokedCount = 0;
+
+  start() {
+    this._registerActions(
+      createActionBindings([[actions.countUp, this._countUp]]),
+    );
+    this._registerReactions(createReactions([this._countReaction]));
+  }
+
+  _countUp = () => {
+    this.count += 1;
+  };
+
+  _countReaction = () => {
+    this.reactionInvokedCount += 1;
+  };
+}
+
+describe('FeatureStore', () => {
+  let store = null;
+
+  beforeEach(() => {
+    store = new TestFeatureStore();
+  });
+
+  describe('registering actions', () => {
+    it('starts the actions', () => {
+      store.start();
+      actions.countUp();
+      expect(store.count).toBe(1);
+    });
+    it('starts the reactions', () => {
+      store.start();
+      actions.countUp();
+      expect(store.reactionInvokedCount).toBe(1);
+    });
+  });
+
+  describe('stopping the store', () => {
+    it('stops the actions', () => {
+      store.start();
+      actions.countUp();
+      store.stop();
+      actions.countUp();
+      expect(store.count).toBe(1);
+    });
+    it('stops the reactions', () => {
+      store.start();
+      actions.countUp();
+      store.stop();
+      store.count += 1;
+      expect(store.reactionInvokedCount).toBe(1);
+    });
+  });
+
+  describe('toggling the store', () => {
+    it('restarts the actions correctly', () => {
+      store.start();
+      actions.countUp();
+      store.stop();
+      actions.countUp();
+      store.start();
+      actions.countUp();
+      expect(store.count).toBe(2);
+    });
+    it('restarts the reactions correctly', () => {
+      store.start();
+      actions.countUp();
+      store.stop();
+      actions.countUp();
+      store.start();
+      actions.countUp();
+      expect(store.count).toBe(2);
+    });
+  });
+});
diff --git a/test/helpers/array-helpers.test.ts b/test/helpers/array-helpers.test.ts
new file mode 100644
index 000000000..e8060c2c4
--- /dev/null
+++ b/test/helpers/array-helpers.test.ts
@@ -0,0 +1,15 @@
+import { shuffleArray } from '../../src/helpers/array-helpers';
+
+describe('array_helpers', () => {
+  it('isValidExternalURL', () => {
+    const originalArray = ['a', 'b', 'c'];
+    const shuffledArray = shuffleArray(originalArray);
+
+    // Expect the arrays to not be exactly the same
+    expect(shuffledArray).not.toEqual(originalArray);
+
+    // Expect the arrays to be exactly the same
+    // when both are sorted alphabetically
+    expect(shuffledArray.sort()).toEqual(originalArray.sort());
+  });
+});
diff --git a/test/helpers/url-helpers.test.ts b/test/helpers/url-helpers.test.ts
new file mode 100644
index 000000000..9ef06b905
--- /dev/null
+++ b/test/helpers/url-helpers.test.ts
@@ -0,0 +1,137 @@
+import * as url_helpers from '../../src/helpers/url-helpers';
+
+describe('url_helpers', () => {
+  describe('isValidExternalURL', () => {
+    describe('with string', () => {
+      it('returns false for empty string', () => {
+        const result = url_helpers.isValidExternalURL('');
+        expect(result).toBe(false);
+      });
+
+      it('returns false for whitespace string', () => {
+        const result = url_helpers.isValidExternalURL('  ');
+        expect(result).toBe(false);
+      });
+
+      it('returns false for random string', () => {
+        const result = url_helpers.isValidExternalURL('some random string');
+        expect(result).toBe(false);
+      });
+
+      it('returns false for invalid url', () => {
+        const result = url_helpers.isValidExternalURL('shttps://google');
+        expect(result).toBe(false);
+      });
+
+      it('returns true for valid http url', () => {
+        const result = url_helpers.isValidExternalURL('http://google');
+        expect(result).toBe(true);
+      });
+
+      it('returns true for valid https url', () => {
+        const result = url_helpers.isValidExternalURL('https://google');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('with URL', () => {
+      // Note: not testing the invalid string urls - since the URL ctor itself will raise an error
+
+      it('returns false for invalid url', () => {
+        const result = url_helpers.isValidExternalURL(
+          new URL('shttps://google'),
+        );
+        expect(result).toBe(false);
+      });
+
+      it('returns true for valid http url', () => {
+        const result = url_helpers.isValidExternalURL(new URL('http://google'));
+        expect(result).toBe(true);
+      });
+
+      it('returns true for valid https url', () => {
+        const result = url_helpers.isValidExternalURL(
+          new URL('https://google'),
+        );
+        expect(result).toBe(true);
+      });
+    });
+  });
+
+  describe('fixUrl', () => {
+    it('handles with empty string', () => {
+      const result = url_helpers.fixUrl('');
+      expect(result).toEqual('');
+    });
+
+    it('handles with whitespace string', () => {
+      const result = url_helpers.fixUrl('   ');
+      expect(result).toEqual('   ');
+    });
+
+    it('handles with random string', () => {
+      const result = url_helpers.fixUrl('some random string');
+      expect(result).toEqual('some random string');
+    });
+
+    it('handles string starting with http://', () => {
+      expect(url_helpers.fixUrl('http://some/random/url')).toEqual(
+        'http://some/random/url',
+      );
+      expect(url_helpers.fixUrl('http://some//random//url')).toEqual(
+        'http://some/random/url',
+      );
+
+      const gmailEmbeddedUrl =
+        'https://www.google.com/url?q=https://github.com/ferdium/ferdium-app/issues/87&source=gmail';
+      expect(url_helpers.fixUrl(gmailEmbeddedUrl)).toEqual(gmailEmbeddedUrl); // it should NOT remove the double-slash from the embedded url in the query string
+    });
+
+    it('handles string starting with https://', () => {
+      expect(url_helpers.fixUrl('https://some/random/url')).toEqual(
+        'https://some/random/url',
+      );
+      expect(url_helpers.fixUrl('https://some//random//url')).toEqual(
+        'https://some/random/url',
+      );
+    });
+
+    it('handles string starting with file://', () => {
+      expect(url_helpers.fixUrl('file://some/random/url')).toEqual(
+        'file://some/random/url',
+      );
+      expect(url_helpers.fixUrl('file://some//random//url')).toEqual(
+        'file://some/random/url',
+      );
+    });
+  });
+
+  describe('isValidFileUrl', () => {
+    it('returns false for empty string', () => {
+      const result = url_helpers.isValidFileUrl('');
+      expect(result).toBe(false);
+    });
+
+    it('returns false for whitespace string', () => {
+      const result = url_helpers.isValidFileUrl('  ');
+      expect(result).toBe(false);
+    });
+
+    it('returns false for random string', () => {
+      const result = url_helpers.isValidFileUrl('some random string');
+      expect(result).toBe(false);
+    });
+
+    it('returns false for invalid url', () => {
+      const result = url_helpers.isValidFileUrl('sfile://google');
+      expect(result).toBe(false);
+    });
+
+    it('returns true for valid file url', () => {
+      const fileName =
+        process.platform === 'win32' ? 'file:///c:\\' : 'file:///';
+      const result = url_helpers.isValidFileUrl(fileName);
+      expect(result).toBe(true);
+    });
+  });
+});
diff --git a/test/jsUtils.test.ts b/test/jsUtils.test.ts
new file mode 100644
index 000000000..8ef69b46f
--- /dev/null
+++ b/test/jsUtils.test.ts
@@ -0,0 +1,113 @@
+import * as jsUtils from '../src/jsUtils';
+
+describe('jsUtils', () => {
+  describe('ifUndefinedString', () => {
+    it('returns the default value for undefined input', () => {
+      const result = jsUtils.ifUndefinedString(undefined, 'abc');
+      expect(result).toEqual('abc');
+    });
+
+    it('returns the default value for null input', () => {
+      const result = jsUtils.ifUndefinedString(null, 'abc');
+      expect(result).toEqual('abc');
+    });
+
+    it('returns the non-default input value for regular string input', () => {
+      const result = jsUtils.ifUndefinedString('some random string', 'abc');
+      expect(result).toEqual('some random string');
+    });
+  });
+
+  describe('ifUndefined<string>', () => {
+    it('returns the default value for undefined input', () => {
+      const result = jsUtils.ifUndefined<string>(undefined, 'abc');
+      expect(result).toEqual('abc');
+    });
+
+    it('returns the default value for null input', () => {
+      const result = jsUtils.ifUndefined<string>(null, 'abc');
+      expect(result).toEqual('abc');
+    });
+
+    it('returns the non-default input value for regular string input', () => {
+      const result = jsUtils.ifUndefined<string>('some random string', 'abc');
+      expect(result).toEqual('some random string');
+    });
+  });
+
+  describe('ifUndefined<boolean>', () => {
+    it('returns the default value for undefined input', () => {
+      const result = jsUtils.ifUndefined<boolean>(undefined, false);
+      expect(result).toEqual(false);
+    });
+
+    it('returns the default value for null input', () => {
+      const result = jsUtils.ifUndefined<boolean>(null, true);
+      expect(result).toEqual(true);
+    });
+
+    it('returns the non-default input value for regular boolean input', () => {
+      const result = jsUtils.ifUndefined<boolean>(true, false);
+      expect(result).toEqual(true);
+    });
+  });
+
+  describe('ifUndefined<number>', () => {
+    it('returns the default value for undefined input', () => {
+      const result = jsUtils.ifUndefined<number>(undefined, 123);
+      expect(result).toEqual(123);
+    });
+
+    it('returns the default value for null input', () => {
+      const result = jsUtils.ifUndefined<number>(null, 234);
+      expect(result).toEqual(234);
+    });
+
+    it('returns the non-default input value for regular Number input', () => {
+      const result = jsUtils.ifUndefined<number>(1234, 5678);
+      expect(result).toEqual(1234);
+    });
+  });
+
+  describe('convertToJSON', () => {
+    it('returns undefined for undefined input', () => {
+      const result = jsUtils.convertToJSON(undefined);
+      expect(result).toEqual(undefined);
+    });
+
+    it('returns null for null input', () => {
+      const result = jsUtils.convertToJSON(null);
+      expect(result).toEqual(null);
+    });
+
+    it('returns the object for the object input', () => {
+      const result = jsUtils.convertToJSON(['a', 'b']);
+      expect(result).toEqual(['a', 'b']);
+    });
+
+    it('returns the parsed JSON for the string input', () => {
+      const result1 = jsUtils.convertToJSON('{"a":"b","c":"d"}');
+      expect(result1).toEqual({ a: 'b', c: 'd' });
+
+      const result2 = jsUtils.convertToJSON('[{"a":"b"},{"c":"d"}]');
+      expect(result2).toEqual([{ a: 'b' }, { c: 'd' }]);
+    });
+  });
+
+  describe('cleanseJSObject', () => {
+    xit('throws error for undefined input', () => {
+      const result = jsUtils.cleanseJSObject(undefined);
+      expect(result).toThrow();
+    });
+
+    xit('throws error for null input', () => {
+      const result = jsUtils.cleanseJSObject(null);
+      expect(result).toThrow();
+    });
+
+    it('returns cloned object for valid input', () => {
+      const result = jsUtils.cleanseJSObject([{ a: 'b' }, { c: 'd' }]);
+      expect(result).toEqual([{ a: 'b' }, { c: 'd' }]);
+    });
+  });
+});
diff --git a/test/themes/index.test.ts b/test/themes/index.test.ts
new file mode 100644
index 000000000..387a296a8
--- /dev/null
+++ b/test/themes/index.test.ts
@@ -0,0 +1,17 @@
+import makeDefaultThemeConfig from '../../src/themes/default';
+import makeDarkThemeConfig from '../../src/themes/dark';
+import { theme, ThemeType } from '../../src/themes';
+
+describe('Load theme', () => {
+  it('loads default theme', () => {
+    const { colorBackground } = theme('default' as ThemeType);
+    expect(colorBackground).toBe(
+      makeDefaultThemeConfig('default').colorBackground,
+    );
+  });
+
+  it('loads dark theme', () => {
+    const { colorBackground } = theme('dark' as ThemeType);
+    expect(colorBackground).toBe(makeDarkThemeConfig('dark').colorBackground);
+  });
+});