ti2 1.0.7 → 1.0.11

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',
+  };
+  const 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',
@@ -61,15 +77,93 @@ describe('user: booking search', () => {
       expect(value).toBeTruthy();
     }
   });
-  it('should be able to search a travel gate for a booking', async () => {
-    const retVal = await doApiPost({
+  it('should be able to search a for a booking', async () => {
+    const payload = {
+      bookingId: '', supplierId: '', name: '',
+    };
+    const { bookings } = await doApiPost({
       url: `/bookings/${appKey}/${userId}/search`,
       token: userToken,
-      payload: {
-        bookingId: '', supplierId: '', name: '',
-      },
+      payload,
+    });
+    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();
+  });
+
+  it('should be able to search a for a booking product', async () => {
+    const payload = {};
+    const { products } = await doApiPost({
+      url: `/products/${appKey}/${userId}/search`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].searchProducts).toHaveBeenCalled();
+    expect(Array.isArray(products)).toBeTruthy();
+    expect(plugins[0].searchProducts.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].searchProducts.mock.calls[0][0].token).toEqual(token);
+
+    // expect(Array.isArray(retVal.bookings)).toBeTruthy();
+    // expect(retVal.bookings.length > 0).toBeTruthy();
+  });
+  it('should be able to search for availabiility', async () => {
+    const payload = {
+      travelDateStart: '12/30/2025',
+      travelDateEnd: '01/15/2026',
+      dateFormat: 'MM/DD/YYYY',
+      occupancies: [{ paxes: [{ age: 30 }, { age: 40 }] }],
+      currency: 'EUR',
+      market: 'ES',
+      language: 'es',
+      nationality: 'ES',
+    };
+    const { availability } = await doApiPost({
+      url: `/bookings/${appKey}/${userId}/availability`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].searchAvailability).toHaveBeenCalled();
+    expect(Array.isArray(availability)).toBeTruthy();
+    expect(plugins[0].searchAvailability.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].searchAvailability.mock.calls[0][0].token).toEqual(token);
+  });
+  it('should be able to obtain a quote', async () => {
+    const payload = {
+      id: chance.guid(), // availability result id
+      travelDateStart: '12/30/2025',
+      travelDateEnd: '01/15/2026',
+      dateFormat: 'MM/DD/YYYY',
+      occupancies: [{ paxes: [{ age: 30 }, { age: 40 }] }],
+      currency: 'EUR',
+      market: 'ES',
+      language: 'es',
+      nationality: 'ES',
+    };
+    const { quote } = await doApiPost({
+      url: `/bookings/${appKey}/${userId}/quote`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].searchQuote).toHaveBeenCalled();
+    expect(Array.isArray(quote)).toBeTruthy();
+    expect(plugins[0].searchQuote.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].searchQuote.mock.calls[0][0].token).toEqual(token);
+  });
+  it('should be able create a booking', async () => {
+    const payload = {
+      id: chance.guid(),
+    };
+    await doApiPost({
+      url: `/bookings/${appKey}/${userId}/booking`,
+      token: userToken,
+      payload,
     });
-    expect(Array.isArray(retVal.bookings)).toBeTruthy();
-    expect(retVal.bookings.length > 0).toBeTruthy();
+    expect(plugins[0].createBooking).toHaveBeenCalled();
+    expect(plugins[0].createBooking.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].createBooking.mock.calls[0][0].token).toEqual(token);
   });
 });

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/bookings.js

@@ -25,7 +25,6 @@ const bookingsSearch = plugins => async (req, res, next) => {
     });
     return res.json(results);
   } catch (err) {
-    console.log({ err });
     return next(err);
   }
 };
@@ -57,7 +56,121 @@ const bookingsCancel = plugins => async (req, res, next) => {
   }
 };
 
+const bookingsProductSearch = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body: payload,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    // const app = load(appKey);
+    const userAppKeys = (await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    }));
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    const results = await app.searchProducts({
+      token,
+      payload,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const bookingsAvailabilitySearch = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body: payload,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    // const app = load(appKey);
+    const userAppKeys = (await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    }));
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    const results = await app.searchAvailability({
+      token,
+      payload,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const searchQuote = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body: payload,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    // const app = load(appKey);
+    const userAppKeys = (await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    }));
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    assert(payload.id, 'the availability id is required');
+    const results = await app.searchQuote({
+      token,
+      payload,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const createBooking = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body: payload,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    // const app = load(appKey);
+    const userAppKeys = (await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    }));
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    assert(payload.id, 'the quote id is required');
+    const results = await app.createBooking({
+      token,
+      payload,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
 module.exports = plugins => ({
   bookingsSearch: bookingsSearch(plugins),
   bookingsCancel: bookingsCancel(plugins),
+  bookingsProductSearch: bookingsProductSearch(plugins),
+  bookingsAvailabilitySearch: bookingsAvailabilitySearch(plugins),
+  searchQuote: searchQuote(plugins),
+  createBooking: createBooking(plugins),
 });