spyne 0.19.1 → 0.20.0

package/src/tests/channels/route-utils.test.js

@@ -1,106 +1,101 @@
 // const assert = require('assert');
 
-import { SpyneUtilsChannelRoute } from '../../spyne/utils/spyne-utils-channel-route';
-import {postProcessedRouteData, preProcessedRouteData,reduceProcessedRouteData,reducedRoutesArr, mainConfigPreProcessedData, mainConfigPostProcessedData} from '../mocks/routes-data';
+import { SpyneUtilsChannelRoute } from '../../spyne/utils/spyne-utils-channel-route'
+import { postProcessedRouteData, preProcessedRouteData, reduceProcessedRouteData, reducedRoutesArr, mainConfigPreProcessedData, mainConfigPostProcessedData } from '../mocks/routes-data'
 import {
   SpyneConfigData,
   RouteDataForTests,
   windowLocationData
-} from '../mocks/utils-data';
-import { SpyneChannelRoute } from '../../spyne/channels/spyne-channel-route';
-import {path} from 'ramda';
-const R = require('ramda');
-const ObjtoStr = JSON.stringify;
+} from '../mocks/utils-data'
+import { SpyneChannelRoute } from '../../spyne/channels/spyne-channel-route'
+import { path } from 'ramda'
+const R = require('ramda')
+const ObjtoStr = JSON.stringify
 
-const routeConfig = SpyneConfigData.channels.ROUTE;
+const routeConfig = SpyneConfigData.channels.ROUTE
 
 describe('Route Utils', () => {
   it('flattenConfigObjects should return array of params', () => {
-    const finalArr = [ "pageId", "", "imageNum", "author", "hemingway", "author", "hemingway", "imageNum", "pixels", "photogNum", "randomNum", "32",  "holographs|photos|digital|videos"];
-    let arr = SpyneUtilsChannelRoute.flattenConfigObject(routeConfig.routes);
+    const finalArr = ['pageId', '', 'imageNum', 'author', 'hemingway', 'author', 'hemingway', 'imageNum', 'pixels', 'photogNum', 'randomNum', '32', 'holographs|photos|digital|videos']
+    const arr = SpyneUtilsChannelRoute.flattenConfigObject(routeConfig.routes)
     // return true;
-    expect(arr).to.deep.equal(finalArr);
-  });
+    expect(arr).to.deep.equal(finalArr)
+  })
 
   it('get route arr data should remove unused params', () => {
-    const paramsArr = ['pageId', '', 'imageNum', 'author', 'photogNum'];
-    const arr = ['imageNum', 'pageId', 'author'];
-    const routedArr = ['pageId', 'imageNum', 'author'];
-    let routeObj = SpyneUtilsChannelRoute.getRouteArrData(arr, paramsArr);
-    expect(routeObj.paths).to.deep.equal(routedArr);
-  });
-});
+    const paramsArr = ['pageId', '', 'imageNum', 'author', 'photogNum']
+    const arr = ['imageNum', 'pageId', 'author']
+    const routedArr = ['pageId', 'imageNum', 'author']
+    const routeObj = SpyneUtilsChannelRoute.getRouteArrData(arr, paramsArr)
+    expect(routeObj.paths).to.deep.equal(routedArr)
+  })
+})
 
 describe('it should compare two objects for updated keys', () => {
-  let obj1 = {
-    'pageId': 'guide',
-    'section': 'reference'
-  };
-
-  let obj2 = {
-    'pageId': 'guide',
-    'section': 'overview',
-    'menuItem': 'intro-sending-channel-payloads',
-    'type': 'menuItem',
-    'isManualScroll': true
-  };
-
-  let obj3 = {
+  const obj1 = {
+    pageId: 'guide',
+    section: 'reference'
+  }
+
+  const obj2 = {
+    pageId: 'guide',
+    section: 'overview',
+    menuItem: 'intro-sending-channel-payloads',
+    type: 'menuItem',
+    isManualScroll: true
+  }
+
+  const obj3 = {
     ya: 1,
     ubu:3,
     lsd:4,
     aesf:'sadfsd',
     a23rff: 23,
     aasdsf: 234
-  };
+  }
 
-  let routeKeywordsArr = [
+  const routeKeywordsArr = [
     'pageId',
     'section',
     'menuItem'
-  ];
+  ]
 
-  let checkUpdatedKeys = SpyneUtilsChannelRoute.compareRouteKeywords();
+  const checkUpdatedKeys = SpyneUtilsChannelRoute.compareRouteKeywords()
 
   it('first comparison should be done against empty obj', () => {
-    let compareStart = checkUpdatedKeys.compare(obj1);
-    console.log("compare start is ",compareStart);
-    expect(compareStart.pathsChanged).to.deep.equal(['pageId', 'section']);
-  });
+    const compareStart = checkUpdatedKeys.compare(obj1)
+    // console.log('compare start is ', compareStart)
+    expect(compareStart.pathsChanged).to.deep.equal(['pageId', 'section'])
+  })
 
   it('should compare second obj against first', () => {
-    let compare2 = checkUpdatedKeys.compare(obj2, routeKeywordsArr);
-    expect(compare2.pathsChanged).to.deep.equal(['section', 'menuItem']);
-  });
-
+    const compare2 = checkUpdatedKeys.compare(obj2, routeKeywordsArr)
+    expect(compare2.pathsChanged).to.deep.equal(['section', 'menuItem'])
+  })
 
-  it('should conform empty str and and 404s, convert arrays to route config', ()=>{
-    const revisedConfig = SpyneUtilsChannelRoute.conformRouteObject(preProcessedRouteData);
-    expect(revisedConfig).to.deep.equal(postProcessedRouteData);
+  it('should conform empty str and and 404s, convert arrays to route config', () => {
+    const revisedConfig = SpyneUtilsChannelRoute.conformRouteObject(preProcessedRouteData)
+    expect(revisedConfig).to.deep.equal(postProcessedRouteData)
   })
 
-  it('should create route datasets ',()=>{
-    const channelsRouteObj = R.prop('routes', postProcessedRouteData);
+  it('should create route datasets ', () => {
+    const channelsRouteObj = R.prop('routes', postProcessedRouteData)
 
     channelsRouteObj.routePath['bio-.*'] = {
-      'routePath' : {
-        '404' : '.+',
-        'routeName' : 'bioId',
-        'bioLastName' : '.*'
+      routePath : {
+        404 : '.+',
+        routeName : 'bioId',
+        bioLastName : '.*'
       }
-    };
+    }
 
-    const routeDatasetsAndProps = SpyneUtilsChannelRoute.addRouteDatasets(postProcessedRouteData);
+    const routeDatasetsAndProps = SpyneUtilsChannelRoute.addRouteDatasets(postProcessedRouteData)
 
-    const {routeDatasetsArr} = routeDatasetsAndProps;
-    const {routeNamesArr} = routeDatasetsAndProps;
-
-    //console.log(routeNamesArr,' route data sets \n',JSON.stringify(routeDatasetsArr) );
-    //return true;
-    expect(routeDatasetsArr).to.deep.equal(reducedRoutesArr);
+    const { routeDatasetsArr } = routeDatasetsAndProps
+    const { routeNamesArr } = routeDatasetsAndProps
 
+    // console.log(routeNamesArr,' route data sets \n',JSON.stringify(routeDatasetsArr) );
+    // return true;
+    expect(routeDatasetsArr).to.deep.equal(reducedRoutesArr)
   })
-
-
-
-});
+})

package/src/tests/channels/url-utils.test.js

@@ -1,226 +1,226 @@
 // const assert = require('assert');
 
-import { SpyneUtilsChannelRouteUrl } from '../../spyne/utils/spyne-utils-channel-route-url';
-import { SpyneConfigData, RouteDataForTests, routeConfigWithRegexOverride, payloadDataForUrlUtils, urlUtilsArr } from '../mocks/utils-data';
+import { SpyneUtilsChannelRouteUrl } from '../../spyne/utils/spyne-utils-channel-route-url'
+import { SpyneConfigData, RouteDataForTests, routeConfigWithRegexOverride, payloadDataForUrlUtils, urlUtilsArr } from '../mocks/utils-data'
 
-chai.use(require('chai-dom'));
+chai.use(require('chai-dom'))
 
-const routeConfig = SpyneConfigData.channels.ROUTE;
+const routeConfig = SpyneConfigData.channels.ROUTE
 
 describe('URL Utils - Params To Route', () => {
   describe('Route query string should parse into query obj', () => {
     it('output multiple routeData from slash query', () => {
-      let data = RouteDataForTests.multiple.data;
-      let queryStr = RouteDataForTests.multiple.query;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query');
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
+      const data = RouteDataForTests.multiple.data
+      const queryStr = RouteDataForTests.multiple.query
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query')
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
     it('output single routeData from slash query', () => {
-      let data = RouteDataForTests.singleBasic.data;
-      let queryStr = RouteDataForTests.singleBasic.query;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query');
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
+      const data = RouteDataForTests.singleBasic.data
+      const queryStr = RouteDataForTests.singleBasic.query
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query')
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
     it('output home routeData from slash query', () => {
-      let data = RouteDataForTests.home.data;
-      let queryStr = RouteDataForTests.home.query;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query');
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
-  });
+      const data = RouteDataForTests.home.data
+      const queryStr = RouteDataForTests.home.query
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(queryStr, routeConfig, 'query')
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
+  })
 
   describe('Route slash string should parse into query obj', () => {
     it('output multiple routeData from slash query', () => {
-      let data = RouteDataForTests.multiple.data;
-      let slashStr = RouteDataForTests.multiple.slash;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig);
+      const data = RouteDataForTests.multiple.data
+      const slashStr = RouteDataForTests.multiple.slash
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig)
       // console.log('data query multiple1 ',slashStr,paramsFromRoute.routeData);
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
 
     it('output multiple regex routeData from slash query', () => {
-      let data = RouteDataForTests.multipleRegex.data;
-      let slashStr = RouteDataForTests.multipleRegex.slash;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig);
+      const data = RouteDataForTests.multipleRegex.data
+      const slashStr = RouteDataForTests.multipleRegex.slash
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig)
       // console.log('data query regex str to routeData ',data,slashStr,paramsFromRoute.routeData);
       // return true;
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
 
     it('output single routeData from slash query', () => {
-      let data = RouteDataForTests.singleBasic.data;
-      let slashStr = RouteDataForTests.singleBasic.slash;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig);
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
+      const data = RouteDataForTests.singleBasic.data
+      const slashStr = RouteDataForTests.singleBasic.slash
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig)
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
 
     it('output home routeData from slash query', () => {
-      let data = RouteDataForTests.home.data;
-      let slashStr = RouteDataForTests.home.slash;
-      let paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig);
+      const data = RouteDataForTests.home.data
+      const slashStr = RouteDataForTests.home.slash
+      const paramsFromRoute = SpyneUtilsChannelRouteUrl.convertRouteToParams(slashStr, routeConfig)
       // console.log('data query multiple1 ',slashStr,paramsFromRoute.routeData,data);
-      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data));
-    });
-  });
+      expect(JSON.stringify(paramsFromRoute.routeData)).to.equal(JSON.stringify(data))
+    })
+  })
 
   describe('Should create array of route routeData from obj', () => {
     it('should return multiple routeData in arr', () => {
-      let data = RouteDataForTests.multiple.data;
-      let correctRouteArr = RouteDataForTests.multiple.arr;
-      let route = routeConfig.routes.routePath;
-      let routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route);
-      expect(JSON.stringify(routeVal)).to.equal(correctRouteArr);
-    });
+      const data = RouteDataForTests.multiple.data
+      const correctRouteArr = RouteDataForTests.multiple.arr
+      const route = routeConfig.routes.routePath
+      const routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route)
+      expect(JSON.stringify(routeVal)).to.equal(correctRouteArr)
+    })
 
     it('should return single keyword in arr', () => {
-      let data = RouteDataForTests.single.data;
-      let correctRouteArr = RouteDataForTests.single.arr;
-      let route = routeConfig.routes.routePath;
-      let routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route);
-      expect(JSON.stringify(routeVal)).to.equal(correctRouteArr);
-    });
+      const data = RouteDataForTests.single.data
+      const correctRouteArr = RouteDataForTests.single.arr
+      const route = routeConfig.routes.routePath
+      const routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route)
+      expect(JSON.stringify(routeVal)).to.equal(correctRouteArr)
+    })
 
     it('should return home keyword in arr', () => {
-      let data = RouteDataForTests.home.data;
-      let correctRouteArr = RouteDataForTests.home.arr;
-      let route = routeConfig.routes.routePath;
-      let routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route);
+      const data = RouteDataForTests.home.data
+      const correctRouteArr = RouteDataForTests.home.arr
+      const route = routeConfig.routes.routePath
+      const routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route)
       expect(JSON.stringify(routeVal))
-        .to.equal(JSON.stringify(correctRouteArr));
-    });
+        .to.equal(JSON.stringify(correctRouteArr))
+    })
     it('should return empty keyword in arr', () => {
-      let data = RouteDataForTests.empty.data;
-      let correctRouteArr = RouteDataForTests.empty.arr;
-      let route = routeConfig.routes.routePath;
-      let routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route);
+      const data = RouteDataForTests.empty.data
+      const correctRouteArr = RouteDataForTests.empty.arr
+      const route = routeConfig.routes.routePath
+      const routeVal = SpyneUtilsChannelRouteUrl.createRouteArrayFromParams(data, route)
       // console.log('data empty ',JSON.stringify(routeVal),correctRouteArr);
-      expect(1).to.equal(1);
-    });
-  }); // END ARRAY OF ROUTE PARAMS
+      expect(1).to.equal(1)
+    })
+  }) // END ARRAY OF ROUTE PARAMS
   describe('Params should translate to slash routes', () => {
     it('output multiple routeData query', () => {
-      let data = RouteDataForTests.multiple.data;
-      let correctRouteQuery = RouteDataForTests.multiple.slash;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash');
+      const data = RouteDataForTests.multiple.data
+      const correctRouteQuery = RouteDataForTests.multiple.slash
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash')
       // console.log('data query multiple ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
     it('Params based on regex should translate to slash routes', () => {
-      let data = RouteDataForTests.multipleRegex.data;
-      let correctRouteQuery = RouteDataForTests.multipleRegex.slash;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash');
+      const data = RouteDataForTests.multipleRegex.data
+      const correctRouteQuery = RouteDataForTests.multipleRegex.slash
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash')
       // console.log('data query multiple 1',data, correctRouteQuery, routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
 
     it('nested keyword route should translate to slash routes', () => {
-      let data = RouteDataForTests.multiple.data;
-      data = R.omit(['pageId', 'imageNum'], data);
-      let correctRouteQuery = RouteDataForTests.multiple.slash;
-      correctRouteQuery = 'page-one/5/doe';
-      let updatedQuery = 'page-one/5/ubalu';
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery);
+      let data = RouteDataForTests.multiple.data
+      data = R.omit(['pageId', 'imageNum'], data)
+      let correctRouteQuery = RouteDataForTests.multiple.slash
+      correctRouteQuery = 'page-one/5/doe'
+      const updatedQuery = 'page-one/5/ubalu'
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery)
       // console.log('data query multiple 1',data, correctRouteQuery, routeVal);
       // console.log(' data: ',updatedQuery, correctRouteQuery, routeVal);
-      expect(routeVal).to.equal(updatedQuery);
-    });
+      expect(routeVal).to.equal(updatedQuery)
+    })
 
     it('nested keyword route should not display if missing in between slash routes', () => {
-      let data = RouteDataForTests.multiple.data;
-      data = R.omit(['pageId', 'imageNum'], data);
-      let correctRouteQuery = 'page-one';
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery);
-      expect(routeVal).to.equal(correctRouteQuery);
-    });
+      let data = RouteDataForTests.multiple.data
+      data = R.omit(['pageId', 'imageNum'], data)
+      const correctRouteQuery = 'page-one'
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery)
+      expect(routeVal).to.equal(correctRouteQuery)
+    })
 
     it('nested keyword route should translate to hash routes', () => {
-      let thisRouteConfig = R.clone(routeConfig);
-      thisRouteConfig.isHash = true;
-      let data = RouteDataForTests.multiple.data;
-      data = R.omit(['pageId', 'imageNum'], data);
-      let correctRouteQuery = RouteDataForTests.multiple.slash;
-      correctRouteQuery = 'page-one/5/sdfdf';
-      let updatedQuery = 'page-one/5/ubalu';
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, thisRouteConfig, 'slash', correctRouteQuery);
+      const thisRouteConfig = R.clone(routeConfig)
+      thisRouteConfig.isHash = true
+      let data = RouteDataForTests.multiple.data
+      data = R.omit(['pageId', 'imageNum'], data)
+      let correctRouteQuery = RouteDataForTests.multiple.slash
+      correctRouteQuery = 'page-one/5/sdfdf'
+      const updatedQuery = 'page-one/5/ubalu'
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, thisRouteConfig, 'slash', correctRouteQuery)
       // console.log('data query multiple 1',data, correctRouteQuery, routeVal,updatedQuery);
       // console.log(' data: ',updatedQuery, correctRouteQuery, routeVal);
       // return true;
-      expect(routeVal).to.equal(updatedQuery);
-    });
+      expect(routeVal).to.equal(updatedQuery)
+    })
 
     it('output single routeData query', () => {
-      let data = RouteDataForTests.single.data;
-      let correctRouteQuery = RouteDataForTests.single.slash;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash');
+      const data = RouteDataForTests.single.data
+      const correctRouteQuery = RouteDataForTests.single.slash
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash')
       // console.log('data query single ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
     it('output home routeData query', () => {
-      let data = RouteDataForTests.home.data;
-      let correctRouteQuery = RouteDataForTests.home.slash;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash');
+      const data = RouteDataForTests.home.data
+      const correctRouteQuery = RouteDataForTests.home.slash
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash')
       // console.log('data query home ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
     it('output empty routeData query', () => {
-      let data = RouteDataForTests.empty.data;
-      let correctRouteQuery = RouteDataForTests.empty.slash;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery);
+      const data = RouteDataForTests.empty.data
+      const correctRouteQuery = RouteDataForTests.empty.slash
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'slash', correctRouteQuery)
       // console.log('data query empty ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
-  });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
+  })
 
   describe('Params should translate to query routes', () => {
     it('output multiple routeData query', () => {
-      let data = RouteDataForTests.multiple.data;
-      let correctRouteQuery = RouteDataForTests.multiple.query;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query');
+      const data = RouteDataForTests.multiple.data
+      const correctRouteQuery = RouteDataForTests.multiple.query
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query')
       // console.log('data query multiple ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
 
     it('output multiple routeData with regex query', () => {
-      let data = RouteDataForTests.multipleRegex.data;
-      let correctRouteQuery = RouteDataForTests.multipleRegex.query;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query');
+      const data = RouteDataForTests.multipleRegex.data
+      const correctRouteQuery = RouteDataForTests.multipleRegex.query
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query')
       // console.log('data query multiple ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
 
     it('output single routeData query', () => {
-      let data = RouteDataForTests.single.data;
-      let correctRouteQuery = RouteDataForTests.single.query;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query');
+      const data = RouteDataForTests.single.data
+      const correctRouteQuery = RouteDataForTests.single.query
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query')
       // console.log('data query single ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
     it('output home routeData query', () => {
-      let data = RouteDataForTests.home.data;
-      let correctRouteQuery = RouteDataForTests.home.query;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query');
+      const data = RouteDataForTests.home.data
+      const correctRouteQuery = RouteDataForTests.home.query
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query')
       // console.log('data query home ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
     it('output empty routeData query', () => {
-      let data = RouteDataForTests.empty.data;
-      let correctRouteQuery = RouteDataForTests.empty.query;
-      let routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query');
+      const data = RouteDataForTests.empty.data
+      const correctRouteQuery = RouteDataForTests.empty.query
+      const routeVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(data, routeConfig, 'query')
       // console.log('data query empty ',routeVal);
-      expect(correctRouteQuery).to.equal(routeVal);
-    });
-  });
+      expect(correctRouteQuery).to.equal(routeVal)
+    })
+  })
 
   describe('Overrides to regex values are added', () => {
     it('should override pageId home regex', () => {
-      let paramsToRouteVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(payloadDataForUrlUtils, routeConfigWithRegexOverride);
-      expect(paramsToRouteVal).to.equal('');
-    });
+      const paramsToRouteVal = SpyneUtilsChannelRouteUrl.convertParamsToRoute(payloadDataForUrlUtils, routeConfigWithRegexOverride)
+      expect(paramsToRouteVal).to.equal('')
+    })
 
     it('should replace regex with obj value from data', () => {
-      let arrUpdate = SpyneUtilsChannelRouteUrl.checkPayloadForRegexOverrides(urlUtilsArr, payloadDataForUrlUtils);
-      let pageIdStr = arrUpdate[0].pageId;
-      expect(pageIdStr).to.equal('');
-    });
-  });
-});
+      const arrUpdate = SpyneUtilsChannelRouteUrl.checkPayloadForRegexOverrides(urlUtilsArr, payloadDataForUrlUtils)
+      const pageIdStr = arrUpdate[0].pageId
+      expect(pageIdStr).to.equal('')
+    })
+  })
+})

package/src/tests/channels/view-stream-broadcaster.test.js

@@ -3,15 +3,15 @@ import {
   SpyneConfigData,
   RouteDataForTests,
   windowLocationData
-} from '../mocks/utils-data';
-chai.use(require('chai-dom'));
+} from '../mocks/utils-data'
+chai.use(require('chai-dom'))
 
-const ObjtoStr = JSON.stringify;
+const ObjtoStr = JSON.stringify
 
-const routeConfig = SpyneConfigData.channels.ROUTE;
+const routeConfig = SpyneConfigData.channels.ROUTE
 
 describe('ViewStreamBroadcaster', () => {
   it('should placeholder', () => {
-    return true;
-  });
-});
+    return true
+  })
+})

package/src/tests/import.test.js

@@ -1,13 +1,13 @@
 // creation and utility methods
 // operators all come from `rxjs/operators`
-import { map, takeUntil, tap } from 'rxjs/operators';
-const Observable = require('rxjs');
+import { map, takeUntil, tap } from 'rxjs/operators'
+const Observable = require('rxjs')
 
 describe('importing tests import.test.js', () => {
   it('works', () => {
     // throw new Error('ya!')
     // console.log('loaded tests ',Observable);
 
-    expect(true).to.be.true;
-  });
-});
+    expect(true).to.be.true
+  })
+})

package/src/tests/index.js

@@ -1,4 +1,3 @@
-
 // let getGlobalObj = constants.getGlobalObj;
 
 // import {CDN}  from "../app/app-contants";
@@ -9,19 +8,19 @@
 
 function maybeFirst(array) {
   if (array && array.length) {
-    return array[0];
+    return array[0]
   }
 }
 
-var assert = require('assert');
+const assert = require('assert')
 
 describe('maybeFirst', function() {
   it('returns the first element of an array', function() {
-    var result = maybeFirst([1, 2, 3]);
+    const result = maybeFirst([1, 2, 3])
 
-    assert.equal(result, 1, 'maybeFirst([1, 2, 3]) is 1');
-  });
-});
+    assert.equal(result, 1, 'maybeFirst([1, 2, 3]) is 1')
+  })
+})
 
 /*