ti2-ventrata 1.0.3

package/index.test.js

@@ -0,0 +1,237 @@
+/* globals describe, beforeAll, it, expect */
+const R = require('ramda');
+const moment = require('moment');
+const faker = require('faker');
+
+const Plugin = require('./index');
+const fixtureUnits = require('./__fixtures__/units.js');
+
+const app = new Plugin({
+  jwtKey: process.env.ti2_ventrata_jwtKey,
+});
+
+const rnd = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
+describe('search tests', () => {
+  let products;
+  let testProduct = {
+    productName: 'Pub Crawl Tour',
+  }
+  const token = {
+    apiKey: process.env.ti2_ventrata_apiKey,
+    endpoint: process.env.ti2_ventrata_endpoint,
+    octoEnv: process.env.ti2_ventrata_octoEnv,
+    acceptLanguage: process.env.ti2_ventrata_acceptLanguage,
+  };
+  const dateFormat = 'DD/MM/YYYY';
+  beforeAll(async () => {
+    // nada
+  });
+  describe('utilities', () => {
+    describe('pickUnit', () => {
+      it('adult', () => {
+        const result = Plugin.pickUnit(fixtureUnits, [{ age: 40 }]);
+        expect(result.length).toBe(1);
+        expect(result[0]).toContainObject([{ id: 'adult' }]);
+      });
+      it('child', () => {
+        const result = Plugin.pickUnit(fixtureUnits, [{ age: 10 }]);
+        expect(result.length).toBe(1);
+        expect(result[0]).toContainObject([{ id: 'child' }]);
+      });
+      it('senior', () => {
+        const result = Plugin.pickUnit(fixtureUnits, [{ age: 70 }]);
+        expect(result.length).toBe(1);
+        expect(result[0]).toContainObject([{ id: 'senior' }]);
+      });
+      it('family', () => {
+        const result = Plugin.pickUnit(fixtureUnits, [
+          { age: 70 }, { age: 32 }, { age: 32 }, { age: 14 },
+        ]);
+        expect(result.length).toBe(1);
+        expect(result[0]).toContainObject([{ id: 'family' }]);
+      });
+      it.todo('family + one');
+    });
+  });
+  describe('booking process', () => {
+    it('get for all products, a test product should exist', async () => {
+      const retVal = await app.searchProducts({
+        token,
+      });
+      expect(Array.isArray(retVal.products)).toBeTruthy();
+      // console.log(retVal.products.filter(({ productName }) => productName === testProduct.productName));
+      expect(retVal.products).toContainObject([{
+        productName: testProduct.productName,
+      }]);
+      testProduct = {
+        ...retVal.products.find(({ productName }) => productName === testProduct.productName),
+      };
+      expect(testProduct.productId).toBeTruthy();
+    });
+    it('should be able to get a single product', async () => {
+      const retVal = await app.searchProducts({
+        token,
+        payload: {
+          productId: testProduct.productId,
+        }
+      });
+      expect(Array.isArray(retVal.products)).toBeTruthy();
+      expect(retVal.products).toHaveLength(1);
+    });
+    let busProducts = [];
+    it('should be able to get a product by name', async () => {
+      const retVal = await app.searchProducts({
+        token,
+        payload: {
+          productName: '*bus*',
+        }
+      });
+      expect(Array.isArray(retVal.products)).toBeTruthy();
+      expect(retVal.products.length).toBeGreaterThan(0);
+      busProducts = retVal.products;
+    });
+    it('should be able to get quotes', async () => {
+      const retVal = await app.searchQuote({
+        token,
+        payload: {
+          startDate: moment().add(6, 'M').format(dateFormat),
+          endDate: moment().add(6, 'M').add(2, 'd').format(dateFormat),
+          dateFormat,
+          productIds: busProducts.map(({ productId }) => productId),
+          optionIds: busProducts.map(({ options }) => 
+            faker.random.arrayElement(options).optionId
+          ),
+          occupancies: [
+            [{ age: 30 }, { age: 40 }],
+            [{ age: 30 }, { age: 40 }],
+          ],
+        },
+      });
+      expect(retVal).toBeTruthy();
+      ({ quote } = retVal);
+      expect(quote.length).toBeGreaterThan(0);
+      expect(quote[0]).toContainObject([{
+        rateId: 'adult',
+        pricing: expect.toContainObject([{
+          currency: 'USD',
+        }]),
+      }]);
+    });
+    let availabilityKey;
+    it('should be able to get availability', async () => {
+      const retVal = await app.searchAvailability({
+        token,
+        payload: {
+          startDate: moment().add(6, 'M').format(dateFormat),
+          endDate: moment().add(6, 'M').add(2, 'd').format(dateFormat),
+          dateFormat,
+          productIds: [
+            '28ca088b-bc7b-4746-ab06-5971f1ed5a5e',
+            '5d981651-e204-4549-bfbe-691043dd2515'
+          ],
+          optionIds: ['DEFAULT', 'DEFAULT'],
+          occupancies: [
+            [{ age: 30 }, { age: 40 }],
+            [{ age: 30 }, { age: 40 }],
+          ],
+        },
+      });
+      expect(retVal).toBeTruthy();
+      ({ availability } = retVal);
+      expect(availability).toHaveLength(2);
+      expect(availability[0].length).toBeGreaterThan(0)
+      availabilityKey = R.path([0, 0, 'key'], availability);
+      expect(availabilityKey).toBeTruthy();
+    });
+    let booking;
+    const reference = faker.datatype.uuid();
+    it('should be able to create a booking', async () => {
+      const fullName = faker.name.findName().split(' ');
+      const retVal = await app.createBooking({
+        token,
+        payload: {
+          availabilityKey,
+          notes: faker.lorem.paragraph(),
+          holder: {
+            name: fullName[0],
+            surname: fullName[1],
+            phoneNumber: faker.phone.phoneNumber(),
+            emailAddress: `salvador+tests_${faker.lorem.slug()}@tourconnect.com`,
+            country: faker.address.countryCode(),
+            locales:  ['en-US', 'en', 'es'],
+          },
+          reference,
+        },
+      });
+      expect(retVal.booking).toBeTruthy();
+      ({ booking } = retVal);
+      expect(booking).toBeTruthy();
+      expect(R.path(['id'], booking)).toBeTruthy()
+      expect(R.path(['supplierId'], booking)).toBeTruthy()
+      expect(R.path(['cancellable'], booking)).toBeTruthy()
+      // console.log({ booking });
+    });
+    it('should be able to cancel the booking', async () => {
+      const retVal = await app.cancelBooking({
+        token,
+        payload: {
+          bookingId: booking.id,
+          reason: faker.lorem.paragraph(),
+        }
+      });
+      ({ cancellation } = retVal);
+      expect(cancellation).toBeTruthy();
+      expect(cancellation).toBeTruthy();
+      expect(R.path(['id'], cancellation)).toBeTruthy()
+      expect(R.path(['cancellable'], cancellation)).toBeFalsy()
+    });
+    let bookings = [];
+    it('it should be able to search bookings by id', async () => {
+      const retVal = await app.searchBooking({
+        token,
+        payload: {
+          bookingId: booking.id,
+        }
+      });
+      expect(Array.isArray(retVal.bookings)).toBeTruthy();
+      ({ bookings } = retVal);
+      expect(R.path([0, 'id'], bookings)).toBeTruthy()
+    });
+    it('it should be able to search bookings by reference', async () => {
+      const retVal = await app.searchBooking({
+        token,
+        payload: {
+          bookingId: reference,
+        }
+      });
+      expect(Array.isArray(retVal.bookings)).toBeTruthy();
+      ({ bookings } = retVal);
+      expect(R.path([0, 'id'], bookings)).toBeTruthy()
+    });
+    it('it should be able to search bookings by supplierId', async () => {
+      const retVal = await app.searchBooking({
+        token,
+        payload: {
+          bookingId: booking.supplierId,
+        }
+      });
+      expect(Array.isArray(retVal.bookings)).toBeTruthy();
+      ({ bookings } = retVal);
+      expect(R.path([0, 'id'], bookings)).toBeTruthy()
+    });
+    it('it should be able to search bookings by travelDate', async () => {
+      const retVal = await app.searchBooking({
+        token,
+        payload: {
+          travelDateStart: moment().add(6, 'M').format(dateFormat),
+          travelDateEnd: moment().add(6, 'M').add(2, 'd').format(dateFormat),
+          dateFormat,
+        }
+      });
+      expect(Array.isArray(retVal.bookings)).toBeTruthy();
+      ({ bookings } = retVal);
+      expect(R.path([0, 'id'], bookings)).toBeTruthy()
+    });
+ });
+});

package/jest.setup.js

@@ -0,0 +1,38 @@
+/* globals expect */
+// should not require internals but is the only way to make it work on nested instances
+const { equals } = require('expect/build/jasmineUtils');
+const { diff: diffDefault } = require('jest-diff');
+
+require('util').inspect.defaultOptions.depth = 8;
+
+expect.extend({
+  toContainObject(receivedParam, argument) {
+    const received = (() => {
+      if (Array.isArray(receivedParam)) return receivedParam;
+      return [receivedParam];
+    })();
+    const pass = (() => {
+      if (Array.isArray(argument)) {
+        return equals(received, 
+          expect.arrayContaining(argument.map(arg => expect.objectContaining(arg)))
+        );
+      }
+      return equals(received, 
+        expect.arrayContaining([
+          expect.objectContaining(argument)
+        ])
+      );
+    })();
+    if (pass) {
+      return {
+        message: () => (`expected ${this.utils.printReceived(received)} not to contain object ${this.utils.printExpected(argument)}`),
+        pass: true
+      }
+    } else {
+      return {
+        message: () => (diffDefault(received, argument)),
+        pass: false
+      }
+    }
+  }
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "ti2-ventrata",
+  "version": "1.0.3",
+  "description": "Ventrata's TI2 Plugin",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TourConnect/ti2-ventrata.git"
+  },
+  "author": "",
+  "license": "GPLV3",
+  "bugs": {
+    "url": "https://github.com/TourConnect/ti2-ventrata/issues"
+  },
+  "homepage": "https://github.com/TourConnect/ti2-ventrata#readme",
+  "jest": {
+    "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "setupFilesAfterEnv": [
+      "./jest.setup.js"
+    ],
+    "testTimeout": 10000
+  },
+  "dependencies": {
+    "axios": "^0.24.0",
+    "bluebird": "^3.7.2",
+    "jsonwebtoken": "^8.5.1",
+    "moment": "^2.29.1",
+    "ramda": "^0.27.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.4.1",
+    "eslint-config-airbnb": "^19.0.2",
+    "eslint-plugin-import": "^2.25.4",
+    "faker": "^5.5.3",
+    "jest": "^27.4.5",
+    "jest-cli": "^27.4.7",
+    "jest-diff": "^27.4.2"
+  }
+}

package/utils/stringify.js

@@ -0,0 +1,23 @@
+// from https://stackoverflow.com/questions/1714786/query-string-encoding-of-a-javascript-object
+module.exports = initialObj => {
+  const reducer = (obj, parentPrefix = null) => (prev, key) => {
+    const val = obj[key];
+    key = encodeURIComponent(key);
+    const prefix = parentPrefix ? `${parentPrefix}[${key}]` : key;
+
+    if (val == null || typeof val === 'function') {
+      prev.push(`${prefix}=`);
+      return prev;
+    }
+
+    if (['number', 'boolean', 'string'].includes(typeof val)) {
+      prev.push(`${prefix}=${encodeURIComponent(val)}`);
+      return prev;
+    }
+
+    prev.push(Object.keys(val).reduce(reducer(val, prefix), []).join('&'));
+    return prev;
+  };
+
+  return Object.keys(initialObj).reduce(reducer(initialObj), []).join('&');
+}

package/utils/wildcardMatch.js

@@ -0,0 +1,5 @@
+module.exports = (wildcard, str) => {
+  let w = wildcard.replace(/[.+^${}()|[\]\\]/g, '\\$&'); // regexp escape 
+  const re = new RegExp(`^${w.replace(/\*/g,'.*').replace(/\?/g,'.')}$`,'i');
+  return re.test(str); // remove last 'i' above to have case sensitive
+}