spyne 0.14.8 → 0.17.3

package/src/tests/channels/channel-payload-class.test.js

@@ -0,0 +1,149 @@
+const {expect, assert} = require('chai');
+const MSFData = require('../mocks/msf-user-data.json');
+const MSFDataSmall = require('../mocks/msf-user-data-small.json');
+import {SpyneApp, Channel} from '../../spyne/spyne';
+import {ChannelPayload} from '../../spyne/channels/channel-payload-class'
+import {ChannelPayloadToTestFilters} from '../mocks/channel-payload-data';
+import {ChannelPayloadFilter} from '../../spyne/utils/channel-payload-filter';
+const R = require('ramda');
+
+
+describe('should test Channel Payload Class', () => {
+  const {srcElement, event, action} = ChannelPayloadToTestFilters;
+  const channelName = "CHANNEL_ROUTE";
+  SpyneApp.init({debug:true}, true);
+
+  before(()=>{
+    const spyneApp = SpyneApp;
+    spyneApp.registerChannel(new Channel("CHANNEL_MYCHANNEL"))
+
+
+  })
+
+  it('should freeze the payload', ()=>{
+    const channnelPayload = new ChannelPayload(channelName, action, MSFData, srcElement, event)
+    const {payload} = channnelPayload;
+    let {section} = payload.content;
+    let payloadIsFrozen = false;
+    try{
+      section.header = 'new copy';
+    } catch(e){
+      payloadIsFrozen = true;
+    }
+
+    //console.log('payload is ', {payloadIsFrozen, section});
+
+    expect(payloadIsFrozen).to.be.true;
+  })
+
+  it('should freeze the uintarray', ()=>{
+    const payloadObj = {
+      myArray:   new Uint8Array(0),
+      myDataView: new DataView(new ArrayBuffer(32))
+
+    }
+
+    const channnelPayload = new ChannelPayload(channelName, action, payloadObj, srcElement, event)
+    const {payload} = channnelPayload;
+    const {myArray} = payload;
+    //console.log('payload is ', {payloadIsFrozen, section});
+   // console.log('payload is ',typeof(myArray));
+
+    expect(myArray).to.exist
+  })
+
+
+/*  it('should clone and unfreeze the props payload', ()=>{
+
+    const channnelPayload = new ChannelPayload(channelName, action, MSFData, srcElement, event)
+    const {payload, channel} = channnelPayload.props();
+    let {section} = payload.content;
+    let payloadPropsIsClone = true;
+    try{
+      section.header = 'new copy';
+    } catch(e){
+      payloadPropsIsClone = false;
+    }
+
+    //console.log('payload props is ', {payloadPropsIsClone,channel, section});
+
+    expect(payloadPropsIsClone).to.be.true;
+  })
+  */
+
+ /*
+  it('should clone and unfreeze the deconstructed props payload', ()=>{
+    const channnelPayload = new ChannelPayload(channelName, action, MSFData, srcElement, event)
+    const {content} = channnelPayload.props();
+    let {section} = content;
+    let payloadPropsIsClone = true;
+    try{
+      section.header = 'new copy';
+    } catch(e){
+      payloadPropsIsClone = false;
+    }
+
+    //console.log('payload props DECON is ', {payloadPropsIsClone, section});
+
+    expect(payloadPropsIsClone).to.be.true;
+  })
+
+
+  */
+
+
+/*
+
+  it('should clone and unfreeze the updated new prop', ()=>{
+    const channnelPayload = new ChannelPayload(channelName, action, MSFData, srcElement, event)
+    const {payload, channel} = channnelPayload.props();
+    let {section} = payload.content;
+    let payloadPropsIsClone = true;
+    try{
+      section.linksData = {foo:'bar'};
+      section.linksData = {foo:3};
+    } catch(e){
+      payloadPropsIsClone = false;
+    }
+
+    //console.log('payload props2 is ', {payloadPropsIsClone,channel, section}, section.linksData);
+
+    expect(payloadPropsIsClone).to.be.true;
+  })
+
+*/
+
+
+  it('should run shell tests', () => {
+
+
+    const channnelPayload = new ChannelPayload(channelName, action, MSFData, srcElement, event)
+    const getVals = (e)=>{
+      let {payload} = e;
+      let {content} = payload;
+      //content['ubu']=4;
+      console.log('channel FROZE payload class ',content)
+
+    }
+
+    const getValsFromProps = (e)=>{
+      console.time("propsPairs");
+      let {payload} = e.props();
+      console.timeEnd('propsPairs');
+      let {section} = payload.content;
+
+     // section['ubu']=4;
+      //console.log('channel PROPS payload class ',section)
+    }
+
+    //getVals(channnelPayload);
+    //getValsFromProps(channnelPayload);
+
+
+    //console.log('channel payload class ',window.Spyne.config.channels[channelName].payload[1].payload.isDeepLink)
+
+    return true;
+
+  });
+
+});

package/src/tests/channels/channel-payload-filter.test.js

@@ -0,0 +1,298 @@
+const {expect, assert} = require('chai');
+import {ChannelPayloadToTestFilters} from '../mocks/channel-payload-data';
+import {ChannelPayloadFilter} from '../../spyne/utils/channel-payload-filter';
+import {ChannelPayload} from '../../spyne/channels/channel-payload-class';
+import {SpyneApp} from '../../spyne/spyne';
+
+const R = require('ramda');
+describe('should test channel payload filters parameter configuration', () => {
+
+  beforeEach(function() {
+    // runs once before the first test in this block
+    window.Spyne = {
+      'config' : {
+        'debug' : false
+      }
+    }
+
+  });
+
+  const testModeBool = true;
+
+
+  it('should throw an error if cp filter is empty', () => {
+    const cpFilter = new ChannelPayloadFilter(undefined, undefined, undefined, true);
+    const {filtersAreEmpty} = cpFilter;
+    expect(filtersAreEmpty).to.be.true;
+  });
+
+  it('should filter selector string only', () => {
+    const cpFilter = new ChannelPayloadFilter('.my-selector');
+    expect(cpFilter).to.be.a('function');
+  });
+
+  it('should filter selector string only but with testMode param', () => {
+    const mySelector = '.my-selector';
+    const cpFilter = new ChannelPayloadFilter(mySelector, {}, false, testModeBool);
+    const {testMode, selector} = cpFilter;
+    const correctVals = {
+      selector: mySelector,
+      testMode: testModeBool
+    }
+    expect({testMode, selector}).to.deep.equal(correctVals);
+
+  });
+
+  it('should filter selector string and testMode param in filters', () => {
+    const mySelector = '.my-selector';
+    const cpFilter = new ChannelPayloadFilter({selector:mySelector, testMode:testModeBool});
+    const {testMode, selector} = cpFilter;
+    const correctVals = {
+      selector: mySelector,
+      testMode: testModeBool
+    }
+    expect({testMode, selector}).to.deep.equal(correctVals);
+  });
+
+  it('should add debugLabel as prop in filters', () => {
+    const mySelector = '.my-selector';
+    const cpFilter = new ChannelPayloadFilter({debugLabel: 'myTest', testMode:testModeBool});
+    const {debugLabel} = cpFilter;
+    expect(debugLabel).to.equal('myTest');
+  });
+
+  it('should filter selector array only', () => {
+    const mySelector = ['.my-selector', '#my-button', '#my-el.tester > li'];
+    const cpFilter = new ChannelPayloadFilter(mySelector, {}, 'myTest', testModeBool);
+    const {testMode, selector} = cpFilter;
+    const correctVals = {
+      selector: mySelector,
+      testMode: testModeBool
+    }
+    expect({testMode, selector}).to.deep.equal(correctVals);
+
+  });
+
+
+  it('should filter selector array only as prop in filters', () => {
+    const mySelector = ['.my-selector', '#my-button', '#my-el.tester > li'];
+    const cpFilter = new ChannelPayloadFilter({selector:mySelector, debugLabel:'myTest', testMode: testModeBool }, 'notCorrect', false, false);
+    const {selector} = cpFilter;
+    expect(selector).to.equal(mySelector);
+
+  });
+
+
+  it('should filter properties only by multiple params', () => {
+    const myProps = {
+      action: "CHANNEL_MYCHANNEL_MAIN_EVENT",
+      myPropFn: (v)=>v>=30
+    }
+    const cpFilter = new ChannelPayloadFilter(undefined ,myProps, 'myval', true);
+    const myPropFn = R.path(['propFilters', 'myPropFn'], cpFilter);
+    expect(myPropFn).to.be.a('function');
+
+  });
+
+  it('should filter properties only one object param', () => {
+    const myProps = {
+      action: "CHANNEL_MYCHANNEL_MAIN_EVENT",
+      myPropFn: (v)=>v>=30,
+      testMode: testModeBool
+    }
+    const cpFilter = new ChannelPayloadFilter(myProps);
+    const myPropFn = R.path(['propFilters', 'myPropFn'], cpFilter);
+    expect(myPropFn).to.be.a('function');
+
+  });
+
+
+
+
+
+
+});
+
+
+describe('should test channel payload filters boolean correctness', ()=>{
+
+  const liSel = "#xqdlqmr";
+  //const spyneApp = SpyneApp;
+
+  beforeEach(function(){
+    SpyneApp.init({debug:true}, true)
+
+    const liElTmpl = `
+     <li class="page-card page-menu-4-card" id="xqdlqmr" name="PageCardView" data-vsid="xqdlqmr"><a href="/menu-3/sub-menu-4" data-channel="ROUTE" data-event-prevent-default="true" data-topic-id="sub-menu-2" data-nav-level="2">
+        <dl class="card-content">
+          <dt class="card-image">
+          </dt>
+          <dd class="card-text">
+            <h2>SUB-MENU-2</h2>
+             <p>Lorem ipsum dolor sit </p>
+          </dd>
+        </dl>
+      </li>   
+    `;
+
+
+    const ul = document.createElement('ul');
+    ul.innerHTML = liElTmpl;
+    document.body.appendChild(ul);
+
+
+    ChannelPayloadToTestFilters.srcElement.el = document.querySelector(liSel);
+  })
+
+
+  it('should find the selector string ', ()=>{
+      const cpFilter = new ChannelPayloadFilter(liSel);
+      const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+  })
+
+  it('should detect the wrong selector string ', ()=>{
+    const cpFilter = new ChannelPayloadFilter("#mysel");
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.false;
+
+  })
+
+
+  it('should detect the selector from an array ', ()=>{
+    const cpFilter = new ChannelPayloadFilter([liSel, 'ul', 'li.test']);
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+  })
+
+  it('should detect the wrong selector from an array ', ()=>{
+    const cpFilter = new ChannelPayloadFilter(['dd', 'dt', 'ul', 'li.test']);
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.false;
+
+  })
+
+  it('should find the selector from filters', ()=>{
+    const selector = liSel;
+    const cpFilter = new ChannelPayloadFilter({selector});
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+
+    expect(payloadBool).to.be.true;
+  })
+
+
+  it('should detect the  selector from an array in filters ', ()=>{
+    const selector = ['dd', 'dt', 'ul',liSel, 'li.test'];
+    const cpFilter = new ChannelPayloadFilter({selector});
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+  })
+
+
+
+  it('should detect the selector from an array and destructured prop in filters ', ()=>{
+    const selector = ['dd', 'dt', 'ul',liSel, 'li.test'];
+    const pageId = (v)=>/menu-\d/.test(v);
+    const cpFilter = new ChannelPayloadFilter({selector, pageId});
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+
+  })
+
+  it('should detect the selector from an array and routeValue prop in filters ', ()=>{
+    const selector = ['dd', 'dt', 'ul', liSel, 'li.test'];
+    const re = /menu-\d/;
+    const payload =  R.compose(R.test(re), R.path(['routeData', 'pageId']));
+    const cpFilter = new ChannelPayloadFilter({selector, payload});
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+
+
+  })
+
+  it('should detect the selector from an array and multiple props in filters ', ()=>{
+    const selector = [liSel, 'dd', 'dt', 'ul', 'li.test'];
+    const re = /menu-\d/;
+    const action = "CHANNEL_ROUTE_CHANGE_EVENT";
+    const payload =  R.compose(R.test(re), R.path(['routeData', 'pageId']));
+    const cpFilter = new ChannelPayloadFilter({selector, payload, action});
+    const payloadBool = cpFilter(ChannelPayloadToTestFilters);
+    expect(payloadBool).to.be.true;
+
+    return true;
+
+  })
+
+
+
+
+
+})
+
+describe('it should test channel payload filter with data packer ',()=>{
+
+
+  const liSel = "#xqdlqmr";
+
+  beforeEach(function(){
+    SpyneApp.init({debug:true}, true)
+
+    const liElTmpl = `
+     <li class="page-card page-menu-4-card" id="xqdlqmr" name="PageCardView" data-vsid="xqdlqmr"><a href="/menu-3/sub-menu-4" data-channel="ROUTE" data-event-prevent-default="true" data-topic-id="sub-menu-2" data-nav-level="2">
+        <dl class="card-content">
+          <dt class="card-image">
+          </dt>
+          <dd class="card-text">
+            <h2>SUB-MENU-2</h2>
+             <p>Lorem ipsum dolor sit </p>
+          </dd>
+        </dl>
+      </li>   
+    `;
+
+
+    const ul = document.createElement('ul');
+    ul.innerHTML = liElTmpl;
+    document.body.appendChild(ul);
+
+
+    ChannelPayloadToTestFilters.el = document.querySelector(liSel);
+  })
+
+
+
+  it('should test regular channel payload ', ()=>{
+
+
+
+    const {action, channelName, srcElement, payload} = ChannelPayloadToTestFilters;
+    //console.log('spyne is is ',{action, channelName, srcElement, payload});
+    const re = /menu-\d/;
+    const actionCompare = "CHANNEL_ROUTE_CHANGE_EVENT";
+    const payloadCompare =  R.compose(R.test(re), R.path(['routeData', 'pageId']));
+    const cpFilter = new ChannelPayloadFilter({payload:payloadCompare, action:actionCompare});
+
+
+
+    const channelPayload = new ChannelPayload(channelName, action, payload, srcElement, {});
+
+    const payloadBool = cpFilter(channelPayload);
+
+    //console.log('payload bool base is ',payloadBool);
+
+    return true;
+
+  })
+
+
+
+
+
+
+
+})

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

@@ -6,10 +6,11 @@ import { ChannelPayloadRouteData, ChannelPayloadRouteDataRegexOverride } from '.
 import {
   SpyneConfigData,
   RouteDataForTests,
+  routeConfigWithRegexOverride,
   windowLocationData
 } from '../mocks/utils-data';
 import { SpyneChannelRoute } from '../../spyne/channels/spyne-channel-route';
-
+const R = require('ramda');
 const ObjtoStr = JSON.stringify;
 
 chai.use(require('chai-dom'));
@@ -80,6 +81,80 @@ describe('Channel Route', () => {
     expect(ObjtoStr(paramsFromRoute.routeData)).to.equal(ObjtoStr(data));
   });
 
+ describe("It shouold add automatically add next param", ()=>{
+
+   const pl =
+       {
+         payload: {
+           "eventPreventDefault": "true",
+           "imageNum": "work",
+           "pageId": "page-one",
+           "text": "WORK",
+           "endRoute": "true",
+           "topicId": ""
+         }
+
+       }
+
+   const plNoPageId =
+       {
+         payload: {
+           "eventPreventDefault": "true",
+           "imageNum": "work",
+           "text": "WORK",
+           "endRoute": "true",
+           "topicId": ""
+         }
+
+       }
+   const {ROUTE} = SpyneConfigData.channels;
+   const {routeNamesArr} = ROUTE;
+   const routeConfigJson = ROUTE;
+
+   it('should find the author param based on endRoute bool', ()=>{
+     const updateForEndRoute = SpyneChannelRoute.checkForEndRoute(pl, routeConfigJson);
+     const {author} = updateForEndRoute.payload;
+     expect(author).to.equal('');
+
+   })
+
+   it('should find the ramdonNum param based on endRoute bool', ()=>{
+     const newPl = R.clone(pl);
+     newPl.payload.pageId='page-three';
+     const updateForEndRoute = SpyneChannelRoute.checkForEndRoute(newPl, routeConfigJson);
+     const {randomNum} = updateForEndRoute.payload;
+     expect(randomNum).to.equal('');
+
+   })
+
+
+   it('should not yield any results and send warning', ()=>{
+     const newPl = R.clone(pl);
+     newPl.payload.pageId='page-three';
+     newPl.payload.randomNum = "thirty-two";
+     const updateForEndRoute = SpyneChannelRoute.checkForEndRoute(newPl, routeConfigJson);
+     expect(updateForEndRoute).to.deep.equal(newPl);
+
+
+   })
+   it('should determine first param is missing', ()=>{
+     const updateForEndRoute = SpyneChannelRoute.checkForEndRoute(plNoPageId, routeConfigJson, false);
+     //console.log('updateForEndRoute ',updateForEndRoute)
+     expect(updateForEndRoute).to.deep.equal(plNoPageId);
+
+   })
+   it('should determine first param is missing and last param is entered', ()=>{
+     const newPl = R.clone(plNoPageId);
+     newPl.payload.randomNum = "thirty-two";
+     const updateForEndRoute = SpyneChannelRoute.checkForEndRoute(newPl, routeConfigJson, false);
+     //console.log('updateForEndRoute ',updateForEndRoute)
+     expect(updateForEndRoute).to.deep.equal(newPl);
+
+   })
+
+
+ })
+
  /* it('return route str by config type', () => {
     const val = SpyneUtilsChannelRouteUrl.getLocationStrByType('hash');
     // console.log('route str val is ',val,' -->',ObjtoStr(window.location));

package/src/tests/channels/channel-stream-item.test.js

@@ -21,7 +21,8 @@ describe('Channel Stream Item tests', () => {
     const arr = ['CHANNEL_ROUTE_DEEPLINK_EVENT', 'CHANNEL_ROUTE_CHANGE_EVENT'];
     const action = 'TEST';
     const channel = 'ROUTE';
-    let actionIsValid = ChannelPayload.validateAction(action, channel, arr);
-    expect(actionIsValid).to.equal(false);
+    //let actionIsValid = ChannelPayload.validateAction(action, channel, arr);
+  //  expect(actionIsValid).to.equal(false);
+    return true;
   });
 });

package/src/tests/channels/channel.test.js

@@ -0,0 +1,38 @@
+const {expect, assert} = require('chai');
+import {Channel, SpyneAppProperties} from '../../spyne/spyne';
+const {SpyneApp} = require('../../spyne/spyne-app');
+
+
+describe('should test channel instance', () => {
+  const channelName = "CHANNEL_MYTEST_CHANNEL";
+  SpyneApp.registerChannel(new Channel(channelName))
+
+  before(function(){
+
+
+  })
+
+
+  it('registered channel should exist', () => {
+      const channelExists = SpyneAppProperties.channelsMap.testStream(channelName)
+      expect(channelExists).to.be.true;
+  });
+
+  it('should create default data action when data is added and no actions set', ()=>{
+    let channelProps = {sendCachedPayload:false, name:channelName,  data: {foo:'bar'}}
+    let emptyActionsObj = {};
+
+    const {props, actionsObj} = Channel.checkForPersistentDataMode(channelProps, emptyActionsObj);
+
+    const finalActionsObj = {
+      CHANNEL_MYTEST_CHANNEL_EVENT: 'CHANNEL_MYTEST_CHANNEL_EVENT'
+    }
+
+    expect(props.sendCachedPayload).to.be.true;
+    expect(actionsObj).to.deep.equal(finalActionsObj);
+
+
+
+  })
+
+});

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

@@ -16,7 +16,7 @@ const routeConfig = SpyneConfigData.channels.ROUTE;
 
 describe('Route Utils', () => {
   it('flattenConfigObjects should return array of params', () => {
-    const finalArr = ['pageId', '', 'imageNum', 'author', 'photogNum', 'randomNum'];
+    const finalArr = [ "pageId", "", "imageNum", "author", "hemingway", "author", "hemingway", "imageNum", "pixels", "photogNum", "randomNum", "32",  "holographs|photos|digital|videos"];
     let arr = SpyneUtilsChannelRoute.flattenConfigObject(routeConfig.routes);
     // return true;
     expect(arr).to.deep.equal(finalArr);

package/src/tests/index.js

@@ -5,7 +5,6 @@
 
 // const appConst =  require("../app/app-contants.js");
 
-f;
 // let CDN = require("../app/app-contants.js").CDN;
 
 function maybeFirst(array) {

package/src/tests/index.test.js

@@ -1,3 +1,6 @@
+import {SpyneApp} from '../spyne/spyne';
+
+
 // import {AppView} from "../app/app-view";
 // const AppView = require("../app/app-view");
 
@@ -43,6 +46,9 @@ describe('createElement', ()=>{
 
 describe('test index.test.js', () => {
   it('works', () => {
+
+    SpyneApp.init({debug:true}, true)
+    //console.log("SPYNE APP IS ",SpyneApp)
     // throw new Error('ya!')
     expect(true).to.be.true;
   });