@outliant/sunrise-utils 1.0.0

package/test/helpers/taskFilter/taskFieldFilter.spec.js

@@ -0,0 +1,355 @@
+'use strict';
+
+/* eslint-env node, mocha */
+const { expect } = require('chai');
+
+// To test
+const taskFieldFilter = require('../../../helpers/taskFilter/taskFieldFilter');
+
+describe('taskFieldFilter', function () {
+  const filters = [
+    {
+      input: {
+        condition: 'is_equal',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: 'test',
+        second_value: ''
+      },
+      output: { query_string: { fields: ['last_comment'], query: '*test*' } }
+    },
+    {
+      input: {
+        condition: 'is_equal',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'text',
+        value: 'test',
+        second_value: ''
+      },
+      output: {
+        bool: { must: [{ term: { last_comment: { value: 'test' } } }] }
+      }
+    },
+    {
+      input: {
+        condition: 'not_equal',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: 'test',
+        second_value: ''
+      },
+      output: {
+        bool: {
+          must_not: {
+            query_string: { fields: ['last_comment'], query: '*test*' }
+          }
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'is_empty',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: '',
+        second_value: ''
+      },
+      output: {
+        bool: {
+          should: [
+            { bool: { must_not: [{ exists: { field: 'last_comment' } }] } },
+            {
+              bool: {
+                must_not: [{ wildcard: { last_comment: { value: '?*' } } }]
+              }
+            },
+            { term: { last_comment: { value: '' } } }
+          ]
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'is_not_empty',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: '',
+        second_value: ''
+      },
+      output: {
+        bool: {
+          must: [
+            { exists: { field: 'last_comment' } },
+            { wildcard: { last_comment: { value: '?*' } } },
+            { bool: { must_not: [{ term: { last_comment: { value: '' } } }] } }
+          ]
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'is_any_of',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: ['test1', 'test2'],
+        second_value: ''
+      },
+      output: { terms: { last_comment: ['test1', 'test2'] } }
+    },
+    {
+      input: {
+        condition: 'is_any_of',
+        field_id: '',
+        type: 'last_comment',
+        field_type: 'textarea',
+        value: 'test1;test2',
+        second_value: ''
+      },
+      output: { terms: { last_comment: ['test1', 'test2'] } }
+    },
+    {
+      input: {
+        condition: 'is_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: {
+        range: { created_at: { gte: 1675267200000, lte: 1675353599999 } }
+      }
+    },
+    {
+      input: {
+        condition: 'is_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: 1,
+        second_value: ''
+      },
+      output: { bool: { must: [{ term: { created_at: { value: 1 } } }] } }
+    },
+    {
+      input: {
+        condition: 'not_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: {
+        bool: {
+          must_not: {
+            range: { created_at: { gte: 1675267200000, lte: 1675353599999 } }
+          }
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'not_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: 1,
+        second_value: ''
+      },
+      output: {
+        bool: {
+          must_not: { bool: { must: [{ term: { created_at: { value: 1 } } }] } }
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'before',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: { range: { created_at: { lt: 1675267200000 } } }
+    },
+    {
+      input: {
+        condition: 'before',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: 1,
+        second_value: ''
+      },
+      output: { range: { created_at: { lt: 1 } } }
+    },
+    {
+      input: {
+        condition: 'after',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: { range: { created_at: { gt: 1675353599999 } } }
+    },
+    {
+      input: {
+        condition: 'after',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: 1,
+        second_value: ''
+      },
+      output: { range: { created_at: { gt: 1 } } }
+    },
+    {
+      input: {
+        condition: 'between',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: 1677196800000
+      },
+      output: {
+        range: { created_at: { gte: 1675267200000, lte: 1677254399999 } }
+      }
+    },
+    {
+      input: {
+        condition: 'between',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: 1,
+        second_value: 100
+      },
+      output: { range: { created_at: { gte: 1, lte: 100 } } }
+    },
+    {
+      input: {
+        condition: 'between',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'unknwon_type',
+        value: 1675296000000,
+        second_value: 1677196800000
+      },
+      output: null
+    },
+    {
+      input: {
+        condition: 'is_empty',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: null,
+        second_value: ''
+      },
+      output: {
+        bool: {
+          should: [
+            { bool: { must_not: [{ exists: { field: 'created_at' } }] } }
+          ]
+        }
+      }
+    },
+    {
+      input: {
+        condition: 'is_not_empty',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: null,
+        second_value: ''
+      },
+      output: { bool: { must: [{ exists: { field: 'created_at' } }] } }
+    },
+    {
+      input: {
+        condition: 'unknown_condition',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: null,
+        second_value: ''
+      },
+      output: null
+    },
+    {
+      input: {
+        condition: 'less_than_or_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: '1',
+        second_value: ''
+      },
+      output: { range: { created_at: { lte: 1 } } }
+    },
+    {
+      input: {
+        condition: 'greater_than_or_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'number',
+        value: '1',
+        second_value: ''
+      },
+      output: { range: { created_at: { gte: 1 } } }
+    },
+    {
+      input: {
+        condition: 'less_than_or_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: { range: { created_at: { lte: 1675353599999 } } }
+    },
+    {
+      input: {
+        condition: 'greater_than_or_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'date',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: { range: { created_at: { gte: 1675353599999 } } }
+    },
+    {
+      input: {
+        condition: 'greater_than_or_equal',
+        field_id: '',
+        type: 'created_at',
+        field_type: 'unknwon_type',
+        value: 1675296000000,
+        second_value: ''
+      },
+      output: null
+    }
+  ];
+
+  filters.forEach((filter) => {
+    it(`${filter.input.condition}: ${JSON.stringify(
+      filter.input.value
+    )}`, (done) => {
+      expect(taskFieldFilter(filter.input)).to.deep.equal(filter.output);
+      done();
+    });
+  });
+});

package/test/lib/fieldConditions.spec.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/* eslint-env node, mocha */
+const { expect } = require('chai');
+
+// To test
+const fieldConditions = require('../../lib/fieldConditions');
+
+describe('fieldConditions', function () {
+  describe('getConditions', () => {
+    it('should be able to get specific field type conditions', (done) => {
+      const conditions = fieldConditions.getConditions('text');
+      expect(conditions).to.deep.equal(fieldConditions.conditions.text);
+      done();
+    });
+  });
+});

package/test/lib/logger.spec.js

@@ -0,0 +1,117 @@
+'use strict';
+
+/* eslint-env node, mocha */
+const chai = require('chai');
+const testConsole = require('test-console');
+
+// To test
+const logger = require('../../lib/logger');
+
+const assert = chai.assert;
+
+describe('logger', function () {
+  describe('info', () => {
+    it('should log an info text on stdout', (done) => {
+      const output = testConsole.stdout.inspectSync(() => {
+        logger.info('All is well!');
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[INFO]:\n{\n    "Message": "All is well!"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+
+    it('should log an info object on stdout', (done) => {
+      const output = testConsole.stdout.inspectSync(() => {
+        logger.info({ propertyOne: 'propertyOne', propertyTwo: 'propertyTwo' });
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[INFO]:\n{\n    "propertyOne": "propertyOne",\n    "propertyTwo": "propertyTwo"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+  });
+
+  describe('warn', () => {
+    it('Should log a warning text on stderr', (done) => {
+      const output = testConsole.stderr.inspectSync(() => {
+        logger.warn('A bit worried');
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[WARNING]:\n{\n    "Message": "A bit worried"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+
+    it('should log an warning object on stderr', (done) => {
+      const output = testConsole.stderr.inspectSync(() => {
+        logger.warn({ propertyOne: 'propertyOne', propertyTwo: 'propertyTwo' });
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[WARNING]:\n{\n    "propertyOne": "propertyOne",\n    "propertyTwo": "propertyTwo"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+  });
+
+  describe('error', () => {
+    it('should log an error text on stderr', (done) => {
+      const output = testConsole.stderr.inspectSync(() => {
+        logger.error('HEEEELLP!!!');
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[ERROR]:\n{\n    "Message": "HEEEELLP!!!"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+
+    it('should log an error object on stderr', (done) => {
+      const output = testConsole.stderr.inspectSync(() => {
+        logger.error({
+          propertyOne: 'propertyOne',
+          propertyTwo: 'propertyTwo'
+        });
+      });
+
+      try {
+        assert.deepEqual(output, [
+          '[ERROR]:\n{\n    "propertyOne": "propertyOne",\n    "propertyTwo": "propertyTwo"\n}\n'
+        ]);
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+  });
+});

package/test/lib/taskPipeline.spec.js

@@ -0,0 +1,162 @@
+'use strict';
+
+/* eslint-env node, mocha */
+const { expect } = require('chai');
+
+// To test
+const taskPipeline = require('../../lib/taskPipeline');
+
+// Helpers
+const taskFilterHelper = require('../../helpers/taskFilter');
+
+describe('taskPipeline', function () {
+  const testOrgId = 'test-org';
+  const testDepartmentId = 'test-department';
+
+  describe('taskStatusOptions', () => {
+    it('should be equal to taskStatusOptions in task filter helper', (done) => {
+      expect(taskPipeline.taskStatusOptions).to.deep.equal(
+        taskFilterHelper.taskStatusOptions
+      );
+      done();
+    });
+  });
+
+  describe('defaultCustomColumns', () => {
+    it('should be equal to defaultCustomColumns in task filter helper', (done) => {
+      expect(taskPipeline.defaultCustomColumns).to.deep.equal(
+        taskFilterHelper.defaultCustomColumns
+      );
+      done();
+    });
+  });
+
+  describe('buildFiltersQuery', () => {
+    it('should format filter correctly with project filter', (done) => {
+      const filter = taskPipeline.buildFiltersQuery(
+        testOrgId,
+        testDepartmentId,
+        [],
+        { projectId: 'test-project' }
+      );
+      expect(filter).to.deep.equal({
+        bool: {
+          must: [
+            { term: { organization_id: { value: 'test-org' } } },
+            { term: { department_id: { value: 'test-department' } } },
+            { term: { project_id: { value: 'test-project' } } }
+          ]
+        }
+      });
+      done();
+    });
+
+    it('should add default on_hold filter if not present', (done) => {
+      const filter = taskPipeline.buildFiltersQuery(
+        testOrgId,
+        testDepartmentId,
+        [
+          {
+            condition: 'is_equal',
+            field_id: '',
+            type: 'status',
+            field_type: 'select',
+            value: 'pending',
+            second_value: ''
+          }
+        ],
+        { projectId: 'test-project' }
+      );
+
+      expect(filter).to.deep.equal({
+        bool: {
+          must: [
+            { term: { organization_id: { value: 'test-org' } } },
+            { term: { department_id: { value: 'test-department' } } },
+            { term: { project_id: { value: 'test-project' } } },
+            {
+              bool: {
+                must: [
+                  { term: { is_ready: true } },
+                  { term: { is_complete: false } }
+                ]
+              }
+            },
+            {
+              bool: {
+                should: [
+                  { term: { on_hold: false } },
+                  { bool: { must_not: { exists: { field: 'on_hold' } } } }
+                ]
+              }
+            }
+          ]
+        }
+      });
+      done();
+    });
+
+    it('should not add default on_hold filter if present', (done) => {
+      const filter = taskPipeline.buildFiltersQuery(
+        testOrgId,
+        testDepartmentId,
+        [
+          {
+            condition: 'is_equal',
+            field_id: '',
+            type: 'status',
+            field_type: 'select',
+            value: 'on_hold',
+            second_value: ''
+          }
+        ]
+      );
+
+      expect(filter).to.deep.equal({
+        bool: {
+          must: [
+            { term: { organization_id: { value: 'test-org' } } },
+            { term: { department_id: { value: 'test-department' } } },
+            { bool: { must: [{ term: { on_hold: true } }] } }
+          ]
+        }
+      });
+      done();
+    });
+
+    it('should handle unknown filter', (done) => {
+      const filter = taskPipeline.buildFiltersQuery(
+        testOrgId,
+        testDepartmentId,
+        [
+          {
+            condition: 'unknown_condition',
+            field_id: '',
+            type: 'unknown_type',
+            field_type: 'number',
+            value: 'on_hold',
+            second_value: ''
+          }
+        ]
+      );
+
+      expect(filter).to.deep.equal({
+        bool: {
+          must: [
+            { term: { organization_id: { value: 'test-org' } } },
+            { term: { department_id: { value: 'test-department' } } },
+            {
+              bool: {
+                should: [
+                  { term: { on_hold: false } },
+                  { bool: { must_not: { exists: { field: 'on_hold' } } } }
+                ]
+              }
+            }
+          ]
+        }
+      });
+      done();
+    });
+  });
+});