feat(BBD-628): Add transformRefinements (#77)

Author: Vic-Dev

src/core/bridge.ts

@@ -1,6 +1,6 @@
 import * as axios from 'axios';
 import { Request } from '../models/request';
-import { Record, RefinementResults, Results } from '../models/response';
+import { Navigation, RangeRefinement, Record, RefinementResults, Results } from '../models/response';
 import { Query } from './query';
 
 const SEARCH = '/search';
@@ -43,7 +43,8 @@ export abstract class AbstractBridge {
     if (request === null) return this.generateError(INVALID_QUERY_ERROR, callback);
 
     const response = this.fireRequest(this.bridgeUrl, request, queryParams)
-      .then((res) => res.records ? Object.assign(res, { records: res.records.map(this.convertRecordFields) }) : res);
+      .then(AbstractBridge.transformRecords)
+      .then(AbstractBridge.transformRefinements);
     return this.handleResponse(response, callback);
   }
 
@@ -106,7 +107,24 @@ export abstract class AbstractBridge {
       });
   }
 
-  private convertRecordFields(record: RawRecord): Record | RawRecord {
+  static transform(response: any, key: string, callback: Function) {
+    if (response[key]) {
+      return Object.assign(response, { [key]: response[key].map(callback) });
+    } else {
+      return response;
+    }
+  }
+
+  static transformRecords(response: any) {
+    return AbstractBridge.transform(response, 'records', AbstractBridge.convertRecordFields);
+  }
+
+  static transformRefinements(response: any) {
+    const transformed = AbstractBridge.transform(response, 'availableNavigation', AbstractBridge.convertRefinement);
+    return AbstractBridge.transform(transformed, 'selectedNavigation', AbstractBridge.convertRefinement);
+  }
+
+  static convertRecordFields(record: RawRecord): Record | RawRecord {
     const converted = Object.assign(record, { id: record._id, url: record._u, title: record._t });
     delete converted._id;
     delete converted._u;
@@ -119,6 +137,19 @@ export abstract class AbstractBridge {
 
     return converted;
   }
+
+  static convertRefinement(navigation: Navigation): Navigation {
+    if (navigation.range) {
+      navigation.refinements = navigation.refinements
+        .map((ref: RangeRefinement) => ({
+          ...ref,
+          high: parseFloat(<any>ref.high),
+          low: parseFloat(<any>ref.low)
+        }));
+    }
+
+    return navigation;
+  }
 }
 
 export class CloudBridge extends AbstractBridge {

test/unit/core/bridge.ts

@@ -1,12 +1,12 @@
 import * as mock from 'xhr-mock';
-import { BrowserBridge, CloudBridge } from '../../../src/core/bridge';
+import { AbstractBridge, BrowserBridge, CloudBridge } from '../../../src/core/bridge';
 import { Query } from '../../../src/core/query';
 import suite from '../_suite';
 
 const CLIENT_KEY = 'XXX-XXX-XXX-XXX';
 const CUSTOMER_ID = 'services';
 
-suite('Bridge', ({ expect, spy }) => {
+suite('Bridge', ({ expect, spy, stub }) => {
   let bridge;
   let query;
 
@@ -45,7 +45,7 @@ suite('Bridge', ({ expect, spy }) => {
       }));
   });
 
-  it('should be accept a direct query string', () => {
+  it('should accept a direct query string', () => {
     mock.post(`https://${CUSTOMER_ID}.groupbycloud.com:443/api/v1/search`, (req, res) => {
       const body = JSON.parse(req.body());
       expect(body.query).to.eq('skirts');
@@ -57,7 +57,7 @@ suite('Bridge', ({ expect, spy }) => {
     return bridge.search('skirts');
   });
 
-  it('should be accept a raw request', () => {
+  it('should accept a raw request', () => {
     mock.post(`https://${CUSTOMER_ID}.groupbycloud.com:443/api/v1/search`, (req, res) => {
       const body = JSON.parse(req.body());
       expect(body.fields).to.eql(['title', 'description']);
@@ -140,33 +140,18 @@ suite('Bridge', ({ expect, spy }) => {
     });
   });
 
-  it('should invoke any configured errorHandler on error', (done) => {
-    mock.post(`https://${CUSTOMER_ID}.groupbycloud.com:443/api/v1/search`, (req, res) => {
-      return res.status(400).body('error');
-    });
-    query = new Query('shoes');
-    bridge.errorHandler = (err) => {
-      expect(err.data).to.eq('error');
-      expect(err.status).to.eq(400);
-      done();
-    };
-
-    bridge.search(query);
-  });
-
-  it('should invoke any configured errorHandler on error and allow downstream promise catching', (done) => {
+  it('should invoke any configured errorHandler on error and allow downstream promise catching', () => {
     const errorHandler = bridge.errorHandler = spy();
     mock.post(`https://${CUSTOMER_ID}.groupbycloud.com:443/api/v1/search`, (req, res) => {
       return res.status(400).body('error');
     });
     query = new Query('shoes');
 
-    bridge.search(query)
+    return bridge.search(query)
       .catch((err) => {
         expect(err.data).to.eq('error');
         expect(err.status).to.eq(400);
         expect(errorHandler).to.be.calledWith(err);
-        done();
       });
   });
 
@@ -185,6 +170,33 @@ suite('Bridge', ({ expect, spy }) => {
             done();
           });
       });
+
+      it('should send HTTPS request', (done) => {
+        mock.post(`https://${CUSTOMER_ID}-cors.groupbycloud.com:443/api/v1/search`, (req, res) => {
+          return res.status(200).body('success');
+        });
+
+        query = new Query('shoes');
+
+        new BrowserBridge(CUSTOMER_ID)
+          .search(query, (err, results) => done());
+      });
+
+      it('should include headers', (done) => {
+        const headers = { a: 'b' };
+        mock.post(`http://${CUSTOMER_ID}-cors.groupbycloud.com/api/v1/search`, (req, res) => {
+          expect(req['_headers']).to.include.keys('a');
+          return res.status(200).body('success');
+        });
+
+        query = new Query('shoes');
+
+        Object.assign(new BrowserBridge(CUSTOMER_ID), { headers })
+          .search(query, (err, results) => {
+            expect(results).to.eq('success');
+            done();
+          });
+      });
     });
 
     describe('refinements()', () => {
@@ -203,32 +215,111 @@ suite('Bridge', ({ expect, spy }) => {
           });
       });
     });
+  });
+
+  describe('AbstractBridge', () => {
+    describe('transform()', () => {
+      it('should execute callback on properties of key', () => {
+        const key = [{ c: 'd' }, { e: 'f' }, { g: 'h' }];
+        const response = <any>{ key, a: 'b' };
+        const callback = spy((obj) => ({ ...obj, value: 'test' }));
+        const result = { ...response, key: [callback(key[0]), callback(key[1]), callback(key[2])] };
 
-    it('should send HTTPS request', (done) => {
-      mock.post(`https://${CUSTOMER_ID}-cors.groupbycloud.com:443/api/v1/search`, (req, res) => {
-        return res.status(200).body('success');
+        expect(AbstractBridge.transform(response, 'key', callback)).to.eql(result);
       });
+    });
 
-      query = new Query('shoes');
+    describe('transformRecords()', () => {
+      it('should return transform() with response, records, and convertRecordFields', () => {
+        const response = { a: 'b' };
+        const returnValue = { c: 'd' };
+        const transform = stub(AbstractBridge, 'transform')
+          .withArgs(response, 'records', AbstractBridge.convertRecordFields).returns(returnValue);
 
-      new BrowserBridge(CUSTOMER_ID)
-        .search(query, (err, results) => done());
+        expect(AbstractBridge.transformRecords(response)).to.eq(returnValue);
+      });
     });
 
-    it('should include headers', (done) => {
-      const headers = { a: 'b' };
-      mock.post(`http://${CUSTOMER_ID}-cors.groupbycloud.com/api/v1/search`, (req, res) => {
-        expect(req['_headers']).to.include.keys('a');
-        return res.status(200).body('success');
+    describe('transformRefinements()', () => {
+      it('should return transform() with response, records, and convertRecordFields', () => {
+        const response = { a: 'b' };
+        const transformedValue = { c: 'd' };
+        const returnValue = { e: 'f' };
+        const transform = stub(AbstractBridge, 'transform');
+        transform.withArgs(response, 'availableNavigation', AbstractBridge.convertRefinement).returns(transformedValue);
+        // tslint:disable-next-line max-line-length
+        transform.withArgs(transformedValue, 'selectedNavigation', AbstractBridge.convertRefinement).returns(returnValue);
+
+        AbstractBridge.transformRefinements(response);
+        expect(AbstractBridge.transformRefinements(response)).to.eq(returnValue);
       });
+    });
 
-      query = new Query('shoes');
+    describe('convertRecordFields()', () => {
+      it('should update properties', () => {
+        const id = '1239';
+        const url = 'www.whateva.ca';
+        const title = 'my stuff';
+        const snippet = 'my snippet';
+        const record = <any>{
+          a: 'b',
+          _id: id,
+          _u: url,
+          _t: title,
+          _snippet: snippet
+        };
+        const transformedRecord = { a: 'b', id, url, title, snippet };
+
+        expect(BrowserBridge.convertRecordFields(record)).to.eql(transformedRecord);
+      });
+    });
 
-      Object.assign(new BrowserBridge(CUSTOMER_ID), { headers })
-        .search(query, (err, results) => {
-          expect(results).to.eq('success');
-          done();
+    describe('convertRefinement()', () => {
+      it('should update value types', () => {
+        let refinements = [
+          { type: 'Range', count: 49, high: '28.0', low: '0.0' },
+          { type: 'Range', count: 479, high: '56.0', low: '28.0' },
+          { type: 'Range', count: 1348, high: '84.0', low: '56.0' },
+        ];
+        const navigation = <any>{
+          name: 'Department',
+          displayName: 'All',
+          type: 'Range',
+          range: true,
+          or: false,
+          refinements,
+          metadata: []
+        };
+        const convertedRefinements = [
+          { type: 'Range', count: 49, high: 28.0, low: 0.0 },
+          { type: 'Range', count: 479, high: 56.0, low: 28.0 },
+          { type: 'Range', count: 1348, high: 84.0, low: 56.0 },
+        ];
+
+        expect(BrowserBridge.convertRefinement(navigation)).to.eql({
+          ...navigation,
+          refinements: convertedRefinements
         });
+      });
+
+      it('should not update value types', () => {
+        let refinements = [
+          {type: 'Value', count: 975, value: 'Black'},
+          {type: 'Value', count: 1064, value: 'Blue'},
+          {type: 'Value', count: 81, value: 'Brown'}
+        ];
+        const navigation = <any>{
+          name: 'Department',
+          displayName: 'All',
+          type: 'Value',
+          range: false,
+          or: false,
+          refinements,
+          metadata: []
+        };
+
+        expect(BrowserBridge.convertRefinement(navigation)).to.eq(navigation);
+      });
     });
   });
 });

wallaby.conf.js

@@ -0,0 +1,21 @@
+module.exports = function(wallaby) {
+  return {
+    env: {
+      type: 'node'
+    },
+    testFramework: 'mocha',
+
+    files: [
+      'src/**/*.ts',
+      {
+        pattern: 'test/**/_suite.ts',
+        instrument: false
+      }
+    ],
+    tests: ['test/unit/**/*.ts'],
+    setup() {
+      const chai = require('chai');
+      chai.use(require('sinon-chai'));
+    }
+  };
+};