upgrade testing envronment

.npmignore

@@ -14,6 +14,7 @@ spec/
 coverage
 jest.config.js
 jest.setup.js
+jest.logger.js
 tsconfig.json
 tsconfig.spec.json
 

jest.logger.js

@@ -0,0 +1,102 @@
+const moment = require('moment');
+const {inspect} = require('util');
+
+class JestLogger {
+
+    /**
+     * @param {{dateFormat:string=,logLevel:string=,format:raw=}=} options
+     */
+    constructor(options) {
+        this.options = Object.assign({}, {
+            dateFormat: 'DD/MMM/YYYY:HH:mm:ss Z',
+            logLevel: 'info',
+            format: 'raw'
+        }, options);
+        if (options == null) {
+            // validate NODE_ENV environment variable
+            if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+                this.options.logLevel = 'debug';
+            }
+        }
+        this.level = JestLogger.Levels.info;
+        if (Object.prototype.hasOwnProperty.call(JestLogger.Levels), this.options.logLevel) {
+            this.level = JestLogger.Levels[this.options.logLevel];
+        }
+
+    }
+
+    static get Levels() {
+        return {
+            error: 0,
+            warn: 1,
+            info: 2,
+            verbose: 3,
+            debug: 4
+        };
+    }
+
+    log() {
+        if (this.level < JestLogger.Levels.info) {
+            return;
+        }
+        this.write.apply(this, ['log'].concat(Array.from(arguments)));
+    }
+
+    info() {
+        if (this.level < JestLogger.Levels.info) {
+            return;
+        }
+        this.write.apply(this, ['info'].concat(Array.from(arguments)));
+    }
+
+    warn() {
+        if (this.level < JestLogger.Levels.warn) {
+            return;
+        }
+        this.write.apply(this, ['warn'].concat(Array.from(arguments)));
+    }
+
+    error() {
+        if (this.level < JestLogger.Levels.error) {
+            return;
+        }
+        this.write.apply(this, ['error'].concat(Array.from(arguments)));
+    }
+
+    verbose() {
+        if (this.level < JestLogger.Levels.verbose) {
+            return;
+        }
+        this.write.apply(this, ['verbose'].concat(Array.from(arguments)));
+    }
+
+    debug() {
+        if (this.level < JestLogger.Levels.debug) {
+            return;
+        }
+        this.write.apply(this, ['debug'].concat(Array.from(arguments)));
+    }
+
+    /**
+     * @param {string} level
+     * @param {...*} arg
+     */
+    // eslint-disable-next-line no-unused-vars
+    write(level, arg) {
+        const args = Array.from(arguments);
+        const log = (level === 'error') ? process.stderr : process.stdout
+        if (args.length > 1) {
+            if (args[args.length - 1] == null) {
+                args.pop();
+            }
+        }
+        // add timestamp
+        args.unshift(moment().format(this.options.dateFormat || 'DD/MMM/YYYY:HH:mm:ss Z'));
+        log.write(args.map((arg) => inspect(arg)).map(
+            (arg) => arg.replace(/^'/, '').replace(/'$/, '')
+        ).join(',') + '\n');
+    }
+}
+// use JestLogger as default logger
+
+module.exports = JestLogger;

jest.setup.js

@@ -1,15 +1,5 @@
-require('source-map-support/register');
-require('./data-model');
-
+const {TraceUtils} = require('@themost/common');
+const JestLogger = require('./jest.logger');
+TraceUtils.useLogger(new JestLogger());
 /* global jest */
-require('dotenv').config();
-Object.assign(global.console , {
-    // uncomment to ignore a specific log level
-    // eslint-disable-next-line no-undef
-    // log: jest.fn(),
-    // debug: jest.fn(),
-    // info: jest.fn(),
-    // warn: jest.fn(),
-    // error: jest.fn(),
-});
 jest.setTimeout(30000);

package.json

@@ -1,15 +1,15 @@
 {
   "name": "@themost/data",
-  "version": "2.11.3",
+  "version": "2.11.4",
   "description": "MOST Web Framework Codename Blueshift - Data module",
   "main": "index.js",
   "scripts": {
     "test": "jest",
     "install-peers": "add-peers"
   },
   "peerDependencies": {
-    "@themost/common": "^2.10.3",
-    "@themost/query": ">=2.11.0",
+    "@themost/common": "^2.10.4",
+    "@themost/query": ">=2.11.2",
     "@themost/xml": "^2"
   },
   "engines": {

spec/CustomQueryExpr.spec.ts

@@ -2,6 +2,7 @@ import {TestUtils} from './adapter/TestUtils';
 import { TestApplication2 } from './TestApplication';
 import { DataContext } from '../types';
 import { DataConfigurationStrategy } from '../data-configuration';
+import {SqliteAdapter} from '@themost/sqlite';
 
 const TempOrderSchema = {
     "name": "TempOrder",
@@ -445,7 +446,7 @@ describe('CustomQueryExpression', () => {
             const ExtendedProducts = context.model('ExtendedProduct');
             await ExtendedProducts.migrateAsync();
             // validate non-insertable columns
-            const db: TestAdapter = context.db as TestAdapter;
+            const db: SqliteAdapter = context.db as SqliteAdapter;
             const columns = await db.table(ExtendedProducts.sourceAdapter).columnsAsync();
             expect(columns.find((item) => item.name === 'priceCategory')).toBeFalsy();
             // insert a temporary object

spec/DataModel.spec.ts

@@ -1,7 +1,6 @@
 import {DataModel, EdmMapping, DataContext} from '../index';
 import { TestApplication } from './TestApplication';
 import { resolve } from 'path';
-import { TestAdapter } from './adapter/TestAdapter';
 
 class Employee {
     public EmployeeID?: number;

spec/DataObjectTag.spec.ts

@@ -1,7 +1,8 @@
-import {resolve} from 'path';
 import {TestUtils} from './adapter/TestUtils';
 import {TestApplication, TestApplication2} from './TestApplication';
 import {DataContext} from '../types';
+import {DataObject} from '../data-object';
+import {DataObjectTag} from '../data-object-tag';
 
 describe('DataObjectTag', () => {
     let app: TestApplication;
@@ -21,9 +22,6 @@ describe('DataObjectTag', () => {
             }
         });
         await TestUtils.executeInTransaction(context, async () => {
-            /**
-             * @type {DataObject}
-             */
             let user = await context.model('User').where('name').equal('luis.nash@example.com').getTypedItem();
             await user.property('tags').insert([
                 'NewUser',
@@ -49,9 +47,6 @@ describe('DataObjectTag', () => {
             }
         });
         await TestUtils.executeInTransaction(context, async () => {
-            /**
-             * @type {DataObject}
-             */
             let user = await context.model('User').where('name').equal('luis.nash@example.com').getTypedItem();
             await expect(user.property('tags').insert([
                 'NewUser',
@@ -82,9 +77,6 @@ describe('DataObjectTag', () => {
             }
         });
         await TestUtils.executeInTransaction(context, async () => {
-            /**
-             * @type {DataObject}
-             */
             let user = await context.model('User').where('name').equal('luis.nash@example.com').getTypedItem();
             await user.property('tags').insert([
                 'NewUser',
@@ -129,18 +121,15 @@ describe('DataObjectTag', () => {
             }
         });
         await TestUtils.executeInTransaction(context, async () => {
-            /**
-             * @type {DataObject}
-             */
             let user = await context.model('User').where('name').equal('luis.nash@example.com').getTypedItem();
-            await user.property('tags').silent().insert([
+            const tags: DataObjectTag = user.property('tags').silent();
+            await tags.insert([
                 'NewUser',
                 'ValidUser'
             ]);
             await expect(user.property('tags').remove([
                 'ValidUser'
             ])).rejects.toThrowError('Access Denied');
-
             user = await context.model('User')
             .where('name').equal('luis.nash@example.com')
             .expand('tags')
@@ -161,9 +150,6 @@ describe('DataObjectTag', () => {
             }
         });
         await TestUtils.executeInTransaction(context, async () => {
-            /**
-             * @type {DataObject}
-             */
             let user = await context.model('User').where('name').equal('luis.nash@example.com').getTypedItem();
             await user.property('tags').silent().insert([
                 'NewUser',

spec/DataPrivilege.exclude.spec.ts

@@ -1,6 +1,6 @@
 import {TestUtils} from './adapter/TestUtils';
 import { TestApplication2 } from './TestApplication';
-import { DataContext } from '../types';
+import {DataAdapter, DataContext} from '../types';
 import {DataModelFilterParser} from '../data-model-filter.parser';
 import { at } from 'lodash';
 import { DataPermissionExclusion } from '../data-permission';
@@ -69,7 +69,7 @@ describe('DataPrivilege', () => {
             $expand: q1.$expand,
             // $fixed: true
         });
-        let result: any[] = await (context.db as TestAdapter).executeAsync(queryUsers.query);
+        let result: any[] = await (context.db as DataAdapter).executeAsync(queryUsers.query, []);
         expect(result.length).toBeTruthy();
 
         q1 = await parser.parseAsync('indexof(context/user/authenticationScope, \'profile\') eq 0');
@@ -80,7 +80,7 @@ describe('DataPrivilege', () => {
             $expand: q1.$expand,
             // $fixed: true
         });
-        result = await (context.db as TestAdapter).executeAsync(queryUsers.query);
+        result = await (context.db as DataAdapter).executeAsync(queryUsers.query, []);
         expect(result.length).toBeTruthy();
 
     });
@@ -129,4 +129,4 @@ describe('DataPrivilege', () => {
         items = await context.model('Order').where('customer/email').equal('luis.nash@example.com').getItems();
         expect(items.length).toBeTruthy();
     });
-});
+});

spec/DataPrivileges.spec.ts

@@ -0,0 +1,107 @@
+import { resolve } from 'path';
+import { DataContext } from '../index';
+import { TestApplication, TestApplication2 } from './TestApplication';
+
+describe('Permissions', () => {
+    let app: TestApplication;
+    let context: DataContext;
+    beforeAll(async () => {
+        app = new TestApplication2();
+        context = app.createContext();
+    });
+    afterAll(async () => {
+        await context.finalizeAsync();
+        await app.finalize();
+    });
+
+    it('should validate read access', async () => {
+        const Products = context.model('Product');
+        const items = await Products.getItems();
+        expect(Array.isArray(items)).toBeTruthy();
+        expect(items.length).toBeTruthy();
+    });
+
+    it('should validate write access', async () => {
+        const Products = context.model('Product');
+        const item = await Products.where('name').equal(
+            'Apple MacBook Air (13.3-inch, 2013 Version)'
+        ).getItem();
+        expect(item).toBeTruthy();
+        expect(item.name).toBe('Apple MacBook Air (13.3-inch, 2013 Version)');
+        item.model = 'APPLE-MACBOOK-AIR-13.3-2013';
+        await expect(Products.save(item)).rejects.toThrow('Access Denied');
+    });
+
+    it('should validate create access', async () => {
+        const Products = context.model('Product');
+        // set context user
+        Object.assign(context, {
+            user: {
+                name: 'christina.ali@example.com'
+        }});
+        const orderedItem = await Products.where('name').equal(
+            'Apple MacBook Air (13.3-inch, 2013 Version)'
+        ).getItem();
+        expect(orderedItem).toBeTruthy();
+        const customer = await context.model('People').where('user/name')
+            .equal('christina.ali@example.com')
+            .getItem();
+        expect(customer).toBeTruthy();
+        const Orders = context.model('Order');
+        let newOrder = {
+            orderedItem,
+            customer
+        };
+        await expect(Orders.save(newOrder)).resolves.toBeTruthy();
+        // try to place an order with different status (should fail)
+        const orderStatus = {
+            name: 'Pickup'
+        }
+        await expect(Orders.save({
+            orderedItem,
+            customer,
+            orderStatus
+        })).rejects.toThrow('Access Denied');
+    });
+
+    it('should validate update access', async () => {
+        await context.model('ActionStatusType').getItems()
+        const Products = context.model('Product');
+        const user = {
+            name: 'margaret.davis@example.com'
+        }
+        // add user to contributors
+        const group = await context.model('Group').where('name').equal('Contributors').getTypedItem();
+        expect(group).toBeTruthy();
+        const members = group.property('members').silent();
+        await members.insert(user);
+        Object.assign(context, {
+            user
+        });
+        const user1 = await context.model('User').find(user)
+            .expand('groups').silent().getItem();
+        expect(user1).toBeTruthy();
+        expect(user1.groups).toBeTruthy();
+        const orderedItem = await Products.where('name').equal(
+            'Lenovo Yoga 2 Pro'
+        ).getItem();
+        expect(orderedItem).toBeTruthy();
+        const customer = await context.model('People').where('user/name')
+            .equal('christina.ali@example.com')
+            .getItem();
+        expect(customer).toBeTruthy();
+        const agent = await context.model('People').where('user/name')
+            .equal(user.name)
+            .getItem();
+        expect(agent).toBeTruthy();
+        const OrderActions = context.model('OrderAction');
+        let newAction = {
+            orderedItem,
+            customer,
+            agent
+        };
+        await expect(OrderActions.save(newAction)).resolves.toBeTruthy();
+
+    });
+
+});