Added unit tests

Author: andersevenrud

.codeclimate.yml

@@ -0,0 +1,10 @@
+version: 2
+plugins:
+  eslint:
+    enabled: true
+  stylelint:
+    enabled: true
+exclude_patterns:
+  - src/tasks/watch.js
+  - __tests__/**
+  - __mocks__/**

.eslintrc

@@ -6,7 +6,10 @@
   },
   "parserOptions": {
     "sourceType": "module",
-    "ecmaVersion": 2018
+    "ecmaVersion": 2018,
+    "ecmaFeatures": {
+      "experimentalObjectRestSpread": true
+    }
   },
   "globals": {
     "Promise": true,

.gitignore

@@ -2,3 +2,4 @@
 .tern-*
 node_modules/
 package-lock.json
+coverage/

.travis.yml

@@ -1,7 +1,20 @@
 language: node_js
 node_js:
-  - 8
+  - "8"
+cache:
+  directories:
+    - node_modules
+env:
+  global:
+    - CC_TEST_REPORTER_ID=c7ef634d96a67d1c98a87dadc02205dc01f9b935cd10699d9d1bce46ccdcbd27
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
 install:
   - npm install
+  - npm install -g jest
 script:
-  - npm run eslint
+  - npm test

__mocks__/packages/Application/dist/main.js

@@ -0,0 +1,3 @@
+{
+  "name": "Application"
+}

__mocks__/packages/Application/metadata.json

@@ -0,0 +1,5 @@
+{
+  "osjs": {
+    "type": "package"
+  }
+}

__mocks__/packages/Application/package.json

@@ -0,0 +1,3 @@
+{
+  "malformed
+}

__mocks__/packages/Failed/metadata.json

@@ -0,0 +1,5 @@
+{
+  "osjs": {
+    "type": "package"
+  }
+}

__mocks__/packages/Failed/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "Theme",
+  "type": "theme"
+}

__mocks__/packages/Theme/dist/main.js

@@ -0,0 +1,5 @@
+{
+  "osjs": {
+    "type": "package"
+  }
+}

__mocks__/packages/Theme/metadata.json

@@ -0,0 +1,12 @@
+const logger = require('consola');
+
+jest.spyOn(console, 'info')
+  .mockImplementation(() => {});
+
+jest.spyOn(console, 'log')
+  .mockImplementation(() => {});
+
+jest.spyOn(process, 'exit')
+  .mockImplementation(() => {});
+
+logger.mockTypes(() => jest.fn());

__mocks__/packages/Theme/package.json

@@ -0,0 +1,24 @@
+const path = require('path');
+const cli = require('../src/cli.js');
+
+describe('cli', () => {
+  const createInstance = (...argv) => cli([
+    '/usr/bin/node',
+    '/tmp/node_modules/.bin/osjs-cli',
+    ...argv
+  ], {
+    root: path.resolve(__dirname, '..')
+  });
+
+  test('should initialize without error', () => {
+    return expect(createInstance())
+      .resolves
+      .toBe(undefined);
+  });
+
+  test('should run info task', () => {
+    return expect(createInstance('info'))
+      .resolves
+      .toBe(undefined);
+  });
+});

__mocks__/setup.js

@@ -0,0 +1,52 @@
+const logger = require('consola');
+const path = require('path');
+const temp = require('temp');
+const fs = require('fs-extra');
+const utils = require('../../src/utils.js');
+const task = require('../../src/tasks/discover.js');
+
+describe('task > package:discover', () => {
+  const root = temp.mkdirSync('osjs-cli-jest');
+  const fname = str => path.resolve(root, str);
+
+  afterAll(() => fs.removeSync(root));
+
+  test('should discover packages', async () => {
+    const defaults = utils.createOptions({root});
+
+    const options =  utils.resolveOptions(defaults, {
+      discover: [
+        path.resolve(__dirname, '../../__mocks__/packages'),
+        path.resolve(__dirname, '../../__mocks__/packages')
+      ]
+    });
+
+    await task['package:discover']
+      .action({
+        logger,
+        options,
+        args: {},
+        commander: null
+      });
+
+    expect(fs.existsSync(fname('dist/metadata.json')))
+      .toBe(true);
+
+    expect(require(fname('dist/metadata.json')))
+      .toMatchObject([{
+        name: 'Application'
+      }, {
+        name: 'Theme',
+        type: 'theme'
+      }]);
+
+    expect(fs.existsSync(fname('dist/apps/Application/main.js')))
+      .toBe(true);
+
+    expect(fs.existsSync(fname('dist/themes/Theme/main.js')))
+      .toBe(true);
+
+    expect(fs.existsSync(fname('dist/apps/Failed')))
+      .toBe(false);
+  });
+});

__tests__/cli.js

@@ -0,0 +1,126 @@
+const logger = require('consola');
+const path = require('path');
+const temp = require('temp');
+const fs = require('fs-extra');
+const utils = require('../../src/utils.js');
+const task = require('../../src/tasks/scaffold.js');
+
+describe('task > make:*', () => {
+  const root = temp.mkdirSync('osjs-cli-jest');
+  const fname = str => path.resolve(root, str);
+
+  const defaults = utils.createOptions({root});
+
+  const options =  utils.resolveOptions(defaults, {
+    discover: [
+      path.resolve(__dirname, '../../__mocks__/packages')
+    ]
+  });
+
+  const runTask = (name, args = {}) => task[name]
+    .action({
+      logger,
+      options,
+      args,
+      commander: null
+    });
+
+  const basicScaffold = async (name, type) => {
+    const filename = `my-${name}.js`;
+    await runTask(`make:${name}`, {type, filename});
+
+    return fs.existsSync(fname(`src/${type}/${filename}`));
+  };
+
+  afterAll(() => fs.removeSync(root));
+
+  describe('make:auth', () => {
+    test('should create client auth adapter', () => {
+      return expect(basicScaffold('auth', 'client'))
+        .resolves
+        .toBe(true);
+    });
+
+    test('should create server auth adapter', async () => {
+      return expect(basicScaffold('auth', 'server'))
+        .resolves
+        .toBe(true);
+    });
+
+    test('should fail when exists', async () => {
+      return expect(basicScaffold('auth', 'server'))
+        .rejects
+        .toBeInstanceOf(Error);
+    });
+  });
+
+  describe('make:settings', () => {
+    test('should create client settings adapter', () => {
+      return expect(basicScaffold('settings', 'client'))
+        .resolves
+        .toBe(true);
+    });
+
+    test('should create server settings adapter', async () => {
+      return expect(basicScaffold('settings', 'server'))
+        .resolves
+        .toBe(true);
+    });
+  });
+
+  describe('make:provider', () => {
+    test('should create client provider adapter', () => {
+      return expect(basicScaffold('provider', 'client'))
+        .resolves
+        .toBe(true);
+    });
+
+    test('should create server provider adapter', async () => {
+      return expect(basicScaffold('provider', 'server'))
+        .resolves
+        .toBe(true);
+    });
+  });
+
+  describe('make:vfs', () => {
+    test('should create client vfs adapter', () => {
+      return expect(basicScaffold('vfs', 'client'))
+        .resolves
+        .toBe(true);
+    });
+
+    test('should create server vfs adapter', async () => {
+      return expect(basicScaffold('vfs', 'server'))
+        .resolves
+        .toBe(true);
+    });
+  });
+
+  describe('make:application', () => {
+    test('should create application', async () => {
+      await runTask('make:application', {
+        dry: true,
+        force: true,
+        name: 'StandardApplication',
+        target: 'src/packages/StandardApplication'
+      });
+
+      expect(fs.readdirSync(fname('src/packages/StandardApplication')))
+        .toHaveLength(7);
+    });
+  });
+
+  describe('make:iframe-application', () => {
+    test('should create application', async () => {
+      await runTask('make:iframe-application', {
+        dry: true,
+        force: true,
+        name: 'IframeApplication',
+        target: 'src/packages/IframeApplication'
+      });
+
+      expect(fs.readdirSync(fname('src/packages/IframeApplication')))
+        .toHaveLength(6);
+    });
+  });
+});

__tests__/tasks/discover.js

@@ -0,0 +1,151 @@
+const path = require('path');
+const utils = require('../src/utils.js');
+
+describe('utils', () => {
+  describe('createOptions', () => {
+    test('should create structured object', () => {
+      const options = utils.createOptions({
+        root: '/tmp'
+      });
+
+      expect(options.dist())
+        .toEqual({
+          root: '/tmp/dist',
+          themes: '/tmp/dist/themes',
+          sounds: '/tmp/dist/sounds',
+          icons: '/tmp/dist/icons',
+          packages: '/tmp/dist/apps',
+          metadata: '/tmp/dist/metadata.json'
+        });
+
+      expect(options)
+        .toMatchObject({
+          cli: '/tmp/src/cli',
+          config: {
+            disabled: [],
+            discover: [],
+            tasks: []
+          },
+          npm: '/tmp/package.json',
+          packages: '/tmp/packages.json',
+          production: false,
+          root: '/tmp'
+        });
+    });
+  });
+
+  describe('resolveOptions', () => {
+    test('should create new object', () => {
+      const task = jest.fn();
+
+      const defaults = utils.createOptions({
+        root: '/tmp'
+      });
+
+      const options =  utils.resolveOptions(defaults, {
+        tasks: [
+          task
+        ],
+        discover: [
+          '/foo'
+        ],
+        disabled: [
+          'foo'
+        ],
+        packages: {
+          metadata: {
+            Foo: {
+              bar: 'baz'
+            }
+          }
+        }
+      });
+
+      expect(options)
+        .toMatchObject({
+          cli: '/tmp/src/cli',
+          config: {
+            disabled: [
+              'foo'
+            ],
+            packages: {
+              metadata: {
+                Foo: {
+                  bar: 'baz'
+                }
+              }
+            },
+            discover: [
+              '/tmp/node_modules',
+              '/foo'
+            ],
+            tasks: [
+              task
+            ]
+          },
+          npm: '/tmp/package.json',
+          packages: '/tmp/packages.json',
+          production: false,
+          root: '/tmp'
+        });
+    });
+  });
+
+  describe('loadTasks', () => {
+    test('should load a list of tasks', () => {
+      const promise = utils.loadTasks({
+        foo: {
+          description: 'foo'
+        }
+      }, [
+        () => ({
+          bar: {
+            description: 'bar'
+          }
+        })
+      ], {});
+
+      return expect(promise)
+        .resolves
+        .toEqual({
+          foo: {
+            description: 'foo'
+          },
+          bar: {
+            description: 'bar'
+          }
+        });
+    });
+  });
+
+  describe('spawnAsync', () => {
+    test('should exit with correct code', () => {
+      return expect(utils.spawnAsync('sh', ['-c', 'exit 123']))
+        .rejects
+        .toBe(123);
+    });
+  });
+
+  describe('npmPackages', () => {
+    test('should get filtered list of metadata', () => {
+      const root = path.resolve(__dirname, '../__mocks__', 'packages');
+      return expect(utils.npmPackages(root))
+        .resolves
+        .toMatchObject([{
+          json: {
+            osjs: {type: 'package'}
+          },
+          meta: {
+            name: 'Application'
+          }
+        }, {
+          json: {
+            osjs: {type: 'package'}
+          },
+          meta: {
+            name: 'Theme'
+          }
+        }]);
+    });
+  });
+});

__tests__/tasks/scaffold.js

@@ -0,0 +1,13 @@
+module.exports = {
+  collectCoverage: true,
+  coverageReporters: ['lcov'],
+
+  setupFilesAfterEnv: [
+    '<rootDir>/__mocks__/setup.js'
+  ],
+
+  coveragePathIgnorePatterns: [
+    'src/tasks/watch.js',
+    '/node_modules/'
+  ]
+};