ti2 1.0.7 → 1.0.8

package/.github/workflows/deploy.yml

@@ -8,14 +8,13 @@ on:
 
 jobs:
   tag:
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    if: github.event.workflow_run.conclusion == 'success' && github.repository == 'ti2travel/ti2'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@master
       - uses: tool3/bump@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          unrelated: true
           user: 'Github Action Job'
           email: 'engineering@tourconnect.com'
           branch: main

package/.github/workflows/tests.yml

@@ -5,13 +5,37 @@ on:
   push:
 
 jobs:
-  build_and_test:
+  test:
+    timeout-minutes: 10
     runs-on: ubuntu-latest
+    container:
+      image: node:erbium
+    services:
+      mysql:
+        image: mysql
+        env:
+          MYSQL_DATABASE: ti2development
+          MYSQL_ALLOW_EMPTY_PASSWORD: true
+          MYSQL_ROOT_PASSWORD: root
+        ports:
+          - 3306:3306
+    env:
+      CI: true
+      DB_URL: 'mysql://root:root@mysql/ti2development'
+      dbCryptoKey: 'YmYzYzE5OWMyNDcwY2I0NzdkOTA3YjFlMDkxN2MxN2I='
+      jwtSecret: '9rifawckwztuKehocJOtGM6deTqICGWzIyc5CqgNyi'
+      frontendKey: 'lYjEJHzb7lbQ1hk3ypjX'
+      adminKey: 'IxEAYjHbbUYhsPjQXwX1'
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm test
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v1
+      with:
+        node-version: 12
+    - name: install dependencies
+      run: npm i
+    - name: create/migrate the database
+      run: npx sequelize db:create && npx sequelize db:migrate
+    - name: seed the database
+      run: npx sequelize db:seed:all
+    - name: run the tests
+      run: npx jest -i --coverage --forceExit

package/README.md

@@ -8,7 +8,7 @@ Tourism Industry Interchange
 Some environment variables are required for ti2 to start
 
 - DB_URL (mysql connection in url format)
-- dbCryptoKey (integration details encription key)
+- dbCryptoKey (integration details encription key, should be a 32 chars random string base64 encoded)
 - adminKey (a key for admin related requests)
 - jwtKey (a key to encrypt user sessions request)
 - frontendKey (an additional optional key to validate the origin of the requests)

package/api.yml

@@ -227,6 +227,30 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/Message'
+
+  /app/{appKey}:
+    delete:
+      security:
+        - bearerAuth: ['admin']
+      tags:
+        - admin
+      summary: Should delete an App, the name of the app should be url safe (no spaces)
+      operationId: deleteApp
+      parameters:
+        - name: appKey
+          in: path
+          description: App name to delete, should be urlsafe and have a correspondant npm package already in the required npm modules as ti2-appName
+          required: true
+          example: 'expedia'
+          schema:
+            type: string
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Message'
   /apps:
     get:
       security:

package/controllers/__tests__/admin.js

@@ -1,10 +1,8 @@
-/* globals describe it expect afterAll */
+/* globals describe it expect */
 
 const chance = require('chance').Chance();
-const request = require('supertest');
-const app = require('../../index');
-const sqldb = require('../../models/db');
-const { slugify } = require('../../test/utils');
+const testUtils = require('../../test/utils');
+const slugify = require('../../test/slugify');
 
 const { env: { adminKey } } = process;
 
@@ -17,26 +15,24 @@ describe('admin', () => {
     packageName: `ti2-${appName}`,
     adminEmail: chance.email(),
   };
+  const { doApiPost, doApiGet } = testUtils({
+    plugins: [appName],
+  });
   let appKey;
   const userId = '536830b6ed19afa44a000002';
-  afterAll(async () => {
-    await sqldb.connectionManager.close();
-  });
   it('should be able to create an app', async () => {
-    const resp = await request(app)
-      .post('/app')
-      .set('Authorization', `Bearer ${adminKey}`)
-      .send(newApp);
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.value).toBeTruthy();
-    appKey = resp.body.value;
+    ({ value: appKey } = await doApiPost({
+      url: '/app',
+      token: adminKey,
+      payload: newApp,
+    }));
+    expect(appKey).toBeTruthy();
   });
   it('the created app should be on the list of apps', async () => {
-    const resp = await request(app)
-      .get('/apps')
-      .set('Authorization', `Bearer ${adminKey}`);
-    expect(resp.statusCode).toBe(200);
-    const { body: { integrations } } = resp;
+    const { integrations } = await doApiGet({
+      url: '/apps',
+      token: adminKey,
+    });
     expect(integrations).toEqual(
       expect.arrayContaining([
         expect.objectContaining(newApp),
@@ -45,18 +41,19 @@ describe('admin', () => {
   });
   it('should be able to reset an app\'s key', async () => {
     const url = `/app/resetAppKey/${newApp.name}`;
-    const resp = await request(app)
-      .get(url)
-      .set('Authorization', `Bearer ${adminKey}`);
-    expect(resp.statusCode).toBe(200);
-    const { body: { value } } = resp;
+    const { value } = await doApiGet({
+      url,
+      token: adminKey,
+    });
     expect(value).toBeTruthy();
     expect(value).not.toBe(appKey);
   });
-  it.skip('should be able to create a new user authentication token', async () => {
-    const resp = await request(app).post('/user')
-      .set('Authorization', `Bearer ${adminKey}`)
-      .send({ userId });
-    expect(resp.statusCode).toBe(200);
+  it('should be able to create a new user authentication token', async () => {
+    const { value } = await doApiPost({
+      url: '/user',
+      token: adminKey,
+      payload: { userId },
+    });
+    expect(value).toBeTruthy();
   });
 });

package/controllers/__tests__/app.js

@@ -1,24 +1,24 @@
-/* globals describe it expect beforeAll, afterAll */
+/* globals describe it expect */
 
 const chance = require('chance').Chance();
-const request = require('supertest');
 const jwt = require('jwt-promise');
-
-const app = require('../../index');
-const sqldb = require('../../models/db');
-const { slugify } = require('../../test/utils');
+const testUtils = require('../../test/utils');
+const slugify = require('../../test/slugify');
 
 const { env: { adminKey, jwtSecret } } = process;
 
 describe('app', () => {
   const appName = slugify(
     chance.company(),
-  ).toLowerCase();
+  );
   const newApp = {
     name: appName,
     packageName: `ti2-${appName}`,
     adminEmail: chance.email(),
   };
+  const { doApiPost, doApiGet, doApiPut } = testUtils({
+    plugins: [appName],
+  });
   let appKey;
   const userId = chance.guid();
   const apiKey = chance.guid();
@@ -31,47 +31,43 @@ describe('app', () => {
     payload: { lorem: chance.paragraph() },
   };
   let encodedKey;
-  beforeAll(async () => {
-    const resp = await request(app)
-      .post('/app')
-      .set('Authorization', `Bearer ${adminKey}`)
-      .send(newApp);
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.value).toBeTruthy();
-    appKey = resp.body.value;
-  });
-  afterAll(async () => {
-    await sqldb.connectionManager.close();
+  it('should create a new app', async () => {
+    ({ value: appKey } = await doApiPost({
+      url: '/app',
+      token: adminKey,
+      payload: newApp,
+    }));
+    expect(appKey).toBeTruthy();
   });
   it('should encode an airbitrary object', async () => {
-    const resp = await request(app)
-      .put(`/app/encode/${appName}`)
-      .set('Authorization', `Bearer ${appKey}`)
-      .send({ payload: encodePayload });
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.value).toBeTruthy();
-    encodedKey = resp.body.value;
+    ({ value: encodedKey } = await doApiPut({
+      url: `/app/encode/${appName}`,
+      token: appKey,
+      payload: encodePayload,
+    }));
+    expect(encodedKey).toBeTruthy();
   });
   it('the encoded key should be decodable', async () => {
     const decoded = await jwt.verify(encodedKey, `${appName}.${jwtSecret}`);
-    expect(decoded.payload).toEqual(expect.objectContaining(encodePayload));
+    expect(decoded).toEqual(expect.objectContaining(encodePayload));
   });
   it('should be able to create a user token for the app', async () => {
-    const resp = await request(app)
-      .post(`/${appName}/${userId}`)
-      .set('Authorization', `Bearer ${appKey}`)
-      .send({
+    const { value } = await doApiPost({
+      url: `/${appName}/${userId}`,
+      token: appKey,
+      payload: {
         tokenHint: apiKey.split('-')[0],
         token,
-      });
-    expect(resp.statusCode).toBe(200);
+      },
+    });
+    expect(parseInt(value, 10)).toBeGreaterThan(0);
   });
   it('should be able to get a list of all tokens related to the app', async () => {
-    const resp = await request(app)
-      .get(`/app/tokens/${appName}`)
-      .set('Authorization', `Bearer ${appKey}`);
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.userAppKeys).toEqual(
+    const { userAppKeys } = await doApiGet({
+      url: `/app/tokens/${appName}`,
+      token: appKey,
+    });
+    expect(userAppKeys).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
           hint: apiKey.split('-')[0],

package/controllers/__tests__/bookings.js

@@ -1,43 +1,59 @@
 /* globals describe it expect */
 
-const { doApiGet, doApiPost } = require('../../test/utils');
+const chance = require('chance').Chance();
+const testUtils = require('../../test/utils');
 
 const { env: { adminKey } } = process;
 
-const newApp = {
-  name: 'travelgate',
-  packageName: 'ti2-travelgate',
-  adminEmail: 'engineering+travelgate@tourconnect.com',
-};
-const appKey = newApp.name;
-const userId = '551394be5ac58e5c76000019';
-const newIntegration = {
-  tokenHint: 'testingToken',
-  token: {
+describe('user: booking search', () => {
+  const newApp = {
+    name: 'travelgate',
+    packageName: 'ti2-travelgate',
+    adminEmail: 'engineering+travelgate@tourconnect.com',
+  };
+  let appKey = newApp.name;
+  const userId = '551394be5ac58e5c76000019';
+  const token = {
     endpoint: 'https://api.travelgatex.com',
-    apiKey: '8ca687f8-7968-4331-7b1a-dfcb276e5e44',
+    apiKey: chance.guid(),
     client: 'tourconnect',
-  },
-};
+  };
+  const newIntegration = {
+    tokenHint: 'testingToken',
+    token,
+  };
+  const {
+    doApiDelete,
+    doApiGet,
+    doApiPost,
+    plugins,
+  } = testUtils({
+    plugins: [newApp.name],
+  });
 
-describe('user: booking search', () => {
   let userToken;
+  it('drop any existing travelgateapp integration', async () => {
+    try {
+      await doApiDelete({
+        url: `/travelgate/${userId}`,
+        token: adminKey,
+        payload: { tokenHint: 'testingToken' },
+      });
+    } catch {}
+    try {
+      await doApiDelete({
+        url: '/app/travelgate',
+        token: adminKey,
+      });
+    } catch {}
+  });
   it('create the travelgate app', async () => {
-    // create the travelgate app
-    // get the list of existing
-    const { integrations } = await doApiGet({
-      url: '/apps',
+    const { value: apiKey } = await doApiPost({
+      url: '/app',
       token: adminKey,
+      payload: newApp,
     });
-    if (!integrations.map(e => e.name).includes(newApp.name)) {
-      // creating the app
-      const { value: appKey } = await doApiPost({
-        url: '/app',
-        token: adminKey,
-        payload: newApp,
-      });
-      expect(appKey).toBeTruthy();
-    }
+    expect(apiKey).toBeTruthy();
     // create the user token
     ({ value: userToken } = await doApiPost({
       url: '/user',
@@ -62,14 +78,20 @@ describe('user: booking search', () => {
     }
   });
   it('should be able to search a travel gate for a booking', async () => {
-    const retVal = await doApiPost({
+    const payload = {
+      bookingId: '', supplierId: '', name: '',
+    };
+    const { bookings } = await doApiPost({
       url: `/bookings/${appKey}/${userId}/search`,
       token: userToken,
-      payload: {
-        bookingId: '', supplierId: '', name: '',
-      },
+      payload,
     });
-    expect(Array.isArray(retVal.bookings)).toBeTruthy();
-    expect(retVal.bookings.length > 0).toBeTruthy();
+    expect(plugins[0].searchHotelBooking).toHaveBeenCalled();
+    expect(Array.isArray(bookings)).toBeTruthy();
+    expect(plugins[0].searchHotelBooking.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].searchHotelBooking.mock.calls[0][0].token).toEqual(token);
+
+    // expect(Array.isArray(retVal.bookings)).toBeTruthy();
+    // expect(retVal.bookings.length > 0).toBeTruthy();
   });
 });

package/controllers/__tests__/ping.js

@@ -1,18 +1,13 @@
 /* global describe, it, expect */
 
-// const should = require('should');
-const request = require('supertest');
-const server = require('../../index');
+const { doApiGet } = require('../../test/utils')();
 
 describe('ping', () => {
   it('should get a server pong', async () => {
-    const response = await request(server)
-      .get('/ping')
-      .set('Accept', 'application/json');
-    expect(response.headers['content-type']).toMatch(/json/);
-    expect(response.statusCode).toBe(200);
-    expect(response.body.error).toBeUndefined();
-    expect(Object.keys(response.body))
+    const response = await doApiGet({
+      url: '/ping',
+    });
+    expect(Object.keys(response))
       .toEqual(expect.arrayContaining([
         'name',
         'description',

package/controllers/__tests__/user.js

@@ -1,10 +1,8 @@
-/* globals describe it expect beforeAll, afterAll, jest, afterEach */
+/* globals describe it expect beforeAll, jest, afterEach */
 
 const chance = require('chance').Chance();
-const request = require('supertest');
-const { getRequireMocks, slugify } = require('../../test/utils');
-const app = require('../../index');
-const sqldb = require('../../models/db');
+const testUtils = require('../../test/utils');
+const slugify = require('../../test/slugify');
 
 const { env: { adminKey } } = process;
 
@@ -17,6 +15,9 @@ describe('user', () => {
     packageName: `ti2-${appName}`,
     adminEmail: chance.email(),
   };
+  const { doApiPost, doApiGet, doApiDelete } = testUtils({
+    plugins: [appName],
+  });
   let appKey;
   const userId = chance.guid();
   let apiKey = chance.guid();
@@ -27,43 +28,39 @@ describe('user', () => {
   };
   beforeAll(async () => {
     // create an App
-    const resp = await request(app)
-      .post('/app')
-      .set('Authorization', `Bearer ${adminKey}`)
-      .send(newApp);
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.value).toBeTruthy();
-    appKey = resp.body.value;
-    // create an App+User Mapping
-    await request(app)
-      .post(`/${appName}/${userId}`)
-      .set('Authorization', `Bearer ${appKey}`)
-      .send({
+    ({ value: appKey } = await doApiPost({
+      url: '/app',
+      token: adminKey,
+      payload: newApp,
+    }));
+    const url = `/${appName}/${userId}`;
+    await doApiPost({
+      url,
+      token: appKey,
+      payload: {
         tokenHint: apiKey.split('-')[0],
         token,
-      });
+      },
+    });
   });
   let userKey;
-  afterAll(async () => {
-    await sqldb.connectionManager.close();
-  });
   afterEach(() => jest.clearAllMocks());
   it('a user should be able to get a user token via an admin key', async () => {
-    const resp = await request(app)
-      .post('/user')
-      .set('Authorization', `Bearer ${adminKey}`)
-      .send({
-        value: userId,
-      });
-    expect(resp.body.value).toBeTruthy();
-    userKey = resp.body.value;
+    ({ value: userKey } = await doApiPost({
+      url: '/user',
+      token: adminKey,
+      payload: {
+        userId,
+      },
+    }));
+    expect(userKey).toBeTruthy();
   });
   it('a user should be able to get a list of it\'s mapped apps', async () => {
-    const resp = await request(app)
-      .get(`/user/${userId}/apps`)
-      .set('Authorization', `Bearer ${userKey}`);
-    expect(resp.statusCode).toBe(200);
-    expect(resp.body.userAppKeys).toEqual(
+    const { userAppKeys } = await doApiGet({
+      token: userKey,
+      url: `/user/${userId}/apps`,
+    });
+    expect(userAppKeys).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
           hint: apiKey.split('-')[0],
@@ -74,17 +71,16 @@ describe('user', () => {
     );
   });
   it('should be able to delete a user/app key', async () => {
-    const resp = await request(app)
-      .delete(`/${appName}/${userId}`)
-      .set('Authorization', `Bearer ${userKey}`)
-      .send({ tokenHint: apiKey.split('-')[0] });
-    expect(resp.statusCode).toBe(200);
-    // make sure the app token is NOT there
-    const respList = await request(app)
-      .get(`/user/${userId}/apps`)
-      .set('Authorization', `Bearer ${userKey}`);
-    expect(respList.statusCode).toBe(200);
-    expect(respList.body.userAppKeys).toEqual(
+    await doApiDelete({
+      url: `/${appName}/${userId}`,
+      token: userKey,
+      payload: { tokenHint: apiKey.split('-')[0] },
+    });
+    const { userAppKeys } = await doApiGet({
+      url: `/user/${userId}/apps`,
+      token: userKey,
+    });
+    expect(userAppKeys).toEqual(
       expect.not.arrayContaining([
         expect.objectContaining({
           hint: apiKey.split('-')[0],
@@ -98,20 +94,20 @@ describe('user', () => {
     // set up new token
     apiKey = chance.guid();
     token.apiKey = apiKey;
-    const resp = await request(app)
-      .post(`/${appName}/${userId}`)
-      .set('Authorization', `Bearer ${userKey}`)
-      .send({
+    await doApiPost({
+      url: `/${appName}/${userId}`,
+      token: userKey,
+      payload: {
         tokenHint: apiKey.split('-')[0],
         token,
-      });
-    expect(resp.statusCode).toBe(200);
+      },
+    });
     // make sure the app token is there
-    const respList = await request(app)
-      .get(`/user/${userId}/apps`)
-      .set('Authorization', `Bearer ${userKey}`);
-    expect(respList.statusCode).toBe(200);
-    expect(respList.body.userAppKeys).toEqual(
+    const { userAppKeys } = await doApiGet({
+      url: `/user/${userId}/apps`,
+      token: userKey,
+    });
+    expect(userAppKeys).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
           hint: apiKey.split('-')[0],
@@ -122,12 +118,11 @@ describe('user', () => {
     );
   });
   it('should be able to get all the methods for an app', async () => {
-    getRequireMocks({ jest, app: newApp });
-    const methods = await request(app)
-      .get(`/app/${appName}/methods`)
-      .set('Authorization', `Bearer ${userKey}`);
-    expect(methods.statusCode).toBe(200);
-    expect(methods.body.methods).toEqual(
+    const { methods } = await doApiGet({
+      url: `/app/${appName}/methods`,
+      token: userKey,
+    });
+    expect(methods).toEqual(
       expect.arrayContaining([
         'validateToken', 'getProduct',
       ]),

package/controllers/admin.js

@@ -12,21 +12,43 @@ const createApp = async (req, res, next) => {
     adminEmail,
   } = req.body;
   try {
-    const newApp = await sqldb.Integration.create({
-      name,
-      packageName,
-      adminEmail,
+    const existing = await sqldb.Integration.findByPk(name, { paranoid: false });
+    const apiKey = await (async () => {
+      if (existing) {
+        await existing.restore();
+        return existing.apiKey;
+      }
+      const newApp = await sqldb.Integration.create({
+        name,
+        packageName,
+        adminEmail,
+      });
+      return newApp.apiKey;
+    })();
+    return res.json({ value: apiKey });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const deleteApp = async (req, res, next) => {
+  const { pathParams: { appKey: name } } = req;
+  try {
+    const newApp = await sqldb.Integration.destroy({
+      where: { name },
     });
     const { apiKey } = newApp;
     return res.json({ value: apiKey });
   } catch (err) {
+    console.log({ err });
     return next(err);
   }
 };
 
 const listApps = async (req, res, next) => {
   try {
-    const integrations = await sqldb.Integration.findAll().map(int => omit(['apiKey'], int.dataValues));
+    const integrations = (await sqldb.Integration.findAll())
+      .map(int => omit(['apiKey'], int.dataValues));
     return res.json({ integrations });
   } catch (err) {
     return next(err);
@@ -71,6 +93,7 @@ const resetIntegrationToken = async (req, res, next) => {
 
 module.exports = {
   createApp,
+  deleteApp,
   createUserToken,
   listApps,
   resetIntegrationToken,

package/controllers/user.js

@@ -22,9 +22,9 @@ const getAppMethods = plugins => async (req, res, next) => {
   const { params: { appKey } } = req;
   try {
     const app = plugins.filter(({ name }) => name === appKey)[0];
-    // load(appKey);
+    const methods = Object.getOwnPropertyNames(app);
     return res.json({
-      methods: Object.getOwnPropertyNames(Object.getPrototypeOf(app)),
+      methods,
     });
   } catch (err) {
     return next(err);

package/index.js

@@ -39,6 +39,7 @@ module.exports = ({
     });
     return new Plugin({ name: pluginName, ...params });
   });
+  // console.log({ plugins });
   const api = {
     ...pingController,
     ...adminController,
@@ -46,6 +47,7 @@ module.exports = ({
     ...userController(plugins),
     ...bookingsController(plugins),
   }; // mehthods that should map to the yaml api spec
+  app.plugins = plugins;
   createMiddleware(schema, app, (_err, middleware) => {
     if (apiDocs) {
       app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(schema));
@@ -170,4 +172,4 @@ module.exports = ({
   });
 
   return app;
-}
+};

package/migrations/20200114173707-addTCApp.js

@@ -1,6 +1,3 @@
-const assert = require('assert');
-const faker = require('faker');
-
 module.exports = {
   up: async queryInterface => {
     const payload = {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "ti2",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Tourist Industry Exchange (TI2)",
   "main": "index.js",
   "scripts": {
-    "test": "jest || echo \"always ok\"",
+    "test": "jest",
     "sequelize": "sequelize-cli"
   },
   "repository": {

package/test/plugin.js

@@ -0,0 +1,17 @@
+/* global jest */
+
+class Plugin {
+  constructor(params = {}) {
+    Object.entries(params).forEach(([attr, value]) => {
+      this[attr] = value;
+    });
+  }
+
+  validateToken = jest.fn();
+
+  getProduct = jest.fn();
+
+  searchHotelBooking = jest.fn(() => ({ bookings: [] }));
+}
+
+module.exports = Plugin;

package/test/slugify.js

@@ -0,0 +1,21 @@
+// source : https://gist.github.com/codeguy/6684588
+
+const slugify = strParam => {
+  let str = strParam.replace(/^\s+|\s+$/g, ''); // trim
+  str = str.toLowerCase();
+
+  // remove accents, swap ñ for n, etc
+  const from = 'àáäâèéëêìíïîòóöôùúüûñç·/_,:;';
+  const to = 'aaaaeeeeiiiioooouuuunc------';
+  for (let i = 0, l = from.length; i < l; i += 1) {
+    str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
+  }
+
+  str = str.replace(/[^a-z0-9 -]/g, '') // remove invalid chars
+    .replace(/\s+/g, '-') // collapse whitespace and replace by -
+    .replace(/-+/g, '-'); // collapse dashes
+
+  return str;
+};
+
+module.exports = slugify;

package/test/utils.js

@@ -1,111 +1,110 @@
+/* global afterAll */
+
 const chance = require('chance').Chance();
 const request = require('supertest');
 const assert = require('assert');
-
-const app = require('../index');
-const pluginMock = require('../controllers/__mocks__/plugin');
+const appReq = require('../index');
+const Plugin = require('./plugin');
+const slugify = require('./slugify');
+const sqldb = require('../models/db');
 
 const { env: { adminKey } } = process;
 
 const timeout = ms => (new Promise(resolve => setTimeout(resolve, ms)));
 
-const getRequireMocks = ({ jest, app: { name } }) => {
-  // create the mock dependencies
-  const mock = jest.mock(`ti2-${name}`, () => ({
-    ...pluginMock(),
-  }), { virtual: true });
-  return require(`ti2-${name}`);
-};
-
-// source : https://gist.github.com/codeguy/6684588
-const slugify = strParam => {
-  let str = strParam.replace(/^\s+|\s+$/g, ''); // trim
-  str = str.toLowerCase();
-
-  // remove accents, swap ñ for n, etc
-  const from = 'àáäâèéëêìíïîòóöôùúüûñç·/_,:;';
-  const to = 'aaaaeeeeiiiioooouuuunc------';
-  for (let i = 0, l = from.length; i < l; i += 1) {
-    str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
-  }
+afterAll(async () => {
+  await sqldb.connectionManager.close();
+});
+module.exports = (appParams = {}) => {
+  const plugins = (() => {
+    if (Array.isArray(appParams.plugins)) {
+      const retVal = {};
+      appParams.plugins.forEach(pluginName => {
+        retVal[pluginName] = Plugin;
+      });
+      return retVal;
+    }
+    return {
+      mockName: Plugin,
+    };
+  })();
+  const app = appReq({
+    startServer: false,
+    ...appParams,
+    plugins,
+  });
 
-  str = str.replace(/[^a-z0-9 -]/g, '') // remove invalid chars
-    .replace(/\s+/g, '-') // collapse whitespace and replace by -
-    .replace(/-+/g, '-'); // collapse dashes
-
-  return str;
-};
-
-const appSetup = async ({ userId: userIdParam } = {}) => {
-  const userId = userIdParam || chance.guid();
-  const appName1 = slugify(
-    chance.company(),
-  ).toLowerCase();
-  const newApp = {
-    name: appName1,
-    packageName: `ti2-${appName1}`,
-    adminEmail: chance.email(),
-  };
-  const apiKey1 = chance.guid();
-  const token = {
-    endpoint: chance.url(),
-    apiKey: apiKey1,
-  };
-  const { body: { value: appKey } } = await request(app)
-    .post('/app')
-    .set('Authorization', `Bearer ${adminKey}`)
-    .send(newApp);
-  await request(app)
-    .post(`/${newApp.name}/${userId}`)
-    .set('Authorization', `Bearer ${appKey}`)
-    .send({
-      tokenHint: token.apiKey.split('-')[0],
-      token,
-    });
-  return {
-    newApp,
+  const doApi = async ({
+    query,
+    verb,
+    payload,
+    url,
     token,
-    appKey,
-    userId,
+    expectStatusCode = 200,
+    rawResponse = false,
+  }) => {
+    let resp;
+    if (token) {
+      resp = await request(app)[verb](url)
+        .set({ Authorization: `Bearer ${token}` })
+        .query(query)
+        .send(payload);
+    } else {
+      resp = await request(app)[verb](url).query(query).send(payload);
+    }
+    // if (resp.statusCode !== 200) assert.strictEqual(resp, `${url}-${expectStatusCode}`);
+    assert.strictEqual(`${url}-${resp.statusCode}`, `${url}-${expectStatusCode}`);
+    if (rawResponse) return resp;
+    return resp.body;
   };
-};
 
-const doApi = async ({
-  query,
-  verb,
-  payload,
-  url,
-  token,
-  expectStatusCode = 200,
-  rawResponse = false,
-}) => {
-  let resp;
-  if (token) {
-    resp = await request(app)[verb](url)
-      .set({ Authorization: `Bearer ${token}` })
-      .query(query)
-      .send(payload);
-  } else {
-    resp = await request(app)[verb](url).query(query).send(payload);
-  }
-  // if (resp.statusCode !== 200) assert.strictEqual(resp, `${url}-${expectStatusCode}`);
-  assert.strictEqual(`${url}-${resp.statusCode}`, `${url}-${expectStatusCode}`);
-  if (rawResponse) return resp;
-  return resp.body;
-};
+  const doApiGet = params => doApi({ ...params, verb: 'get' });
+  const doApiPost = params => doApi({ ...params, verb: 'post' });
+  const doApiPut = params => doApi({ ...params, verb: 'put' });
+  const doApiDelete = params => doApi({ ...params, verb: 'delete' });
 
-const doApiGet = params => doApi({ ...params, verb: 'get' });
-const doApiPost = params => doApi({ ...params, verb: 'post' });
-const doApiPut = params => doApi({ ...params, verb: 'put' });
-const doApiDelete = params => doApi({ ...params, verb: 'delete' });
+  const appSetup = async ({ userId: userIdParam } = {}) => {
+    const userId = userIdParam || chance.guid();
+    const appName1 = slugify(
+      chance.company(),
+    ).toLowerCase();
+    const newApp = {
+      name: appName1,
+      packageName: `ti2-${appName1}`,
+      adminEmail: chance.email(),
+    };
+    const apiKey1 = chance.guid();
+    const token = {
+      endpoint: chance.url(),
+      apiKey: apiKey1,
+    };
+    const { body: { value: appKey } } = await request(app)
+      .post('/app')
+      .set('Authorization', `Bearer ${adminKey}`)
+      .send(newApp);
+    await request(app)
+      .post(`/${newApp.name}/${userId}`)
+      .set('Authorization', `Bearer ${appKey}`)
+      .send({
+        tokenHint: token.apiKey.split('-')[0],
+        token,
+      });
+    return {
+      newApp,
+      token,
+      appKey,
+      userId,
+    };
+  };
 
-module.exports = {
-  appSetup,
-  doApiDelete,
-  doApiGet,
-  doApiPost,
-  doApiPut,
-  getRequireMocks,
-  slugify,
-  timeout,
+  return {
+    appSetup,
+    doApiDelete,
+    doApiGet,
+    doApiPost,
+    doApiPut,
+    slugify,
+    timeout,
+    plugins: app.plugins,
+  };
 };