spyne 0.19.0 → 0.20.0

package/src/tests/utils/channel-action-filter.test.js

@@ -1,133 +1,131 @@
-import { ChannelPayloadFilter } from '../../spyne/utils/channel-payload-filter';
-import { internalViewStreamPayload, internvalRouteChannelPayload } from '../mocks/viewstream-internal-payload.mocks';
-import { spyneDocsDomStr } from '../mocks/spyne-docs.mocks';
+import { ChannelPayloadFilter } from '../../spyne/utils/channel-payload-filter'
+import { internalViewStreamPayload, internvalRouteChannelPayload } from '../mocks/viewstream-internal-payload.mocks'
+import { spyneDocsDomStr } from '../mocks/spyne-docs.mocks'
 
-import * as R from 'ramda';
-import {UnsubscriptionError} from 'rxjs';
-internalViewStreamPayload.srcElement.el = document.querySelector('.has-svg.github');
+import * as R from 'ramda'
+import { UnsubscriptionError } from 'rxjs'
+internalViewStreamPayload.srcElement.el = document.querySelector('.has-svg.github')
 describe('channel action filter', () => {
-  let payload = internalViewStreamPayload;
-  let obj = R.clone(payload);
-  payload = R.mergeDeepRight(obj.channelPayload, obj.srcElement, { channel:obj.channel }, { event:obj.event });
-  payload['action'] = obj.action;
+  let payload = internalViewStreamPayload
+  const obj = R.clone(payload)
+  payload = R.mergeDeepRight(obj.channelPayload, obj.srcElement, { channel:obj.channel }, { event:obj.event })
+  payload.action = obj.action
 
-  let payloadRoute = internvalRouteChannelPayload;
+  const payloadRoute = internvalRouteChannelPayload
 
   beforeEach(function() {
-    document.body.insertAdjacentHTML('afterbegin', spyneDocsDomStr);
-    payload.el = document.querySelector('.has-svg.github');
+    document.body.insertAdjacentHTML('afterbegin', spyneDocsDomStr)
+    payload.el = document.querySelector('.has-svg.github')
   }
-  );
+  )
 
   // remove the html fixture from the DOM
   afterEach(function() {
-    document.body.removeChild(document.getElementById('app'));
-  });
+    document.body.removeChild(document.getElementById('app'))
+  })
   it('Create a new ChannelPayloadFilter', () => {
-    let filter = new ChannelPayloadFilter({test:true});
-    let filterConstructor = filter.constructor.name;
-    return filterConstructor.should.equal('Function');
-  });
+    const filter = new ChannelPayloadFilter({ test:true })
+    const filterConstructor = filter.constructor.name
+    return filterConstructor.should.equal('Function')
+  })
 
   it('String selector only with no data', () => {
-    let filter = new ChannelPayloadFilter({selector: '#header ul li:last-child'});
-    let filterVal = filter(payload);
+    const filter = new ChannelPayloadFilter({ selector: '#header ul li:last-child' })
+    const filterVal = filter(payload)
     // console.log(filterVal, 'filter val string');
-    expect(filterVal).to.eq(true);
-  });
+    expect(filterVal).to.eq(true)
+  })
 
   it('Selectors array contains match but no data', () => {
-    let filter = new ChannelPayloadFilter({selector:['#header ul li:last-child', '#header ul li:first-child' ]});
-    let filterVal = filter(payload);
-    expect(filterVal).to.eq(true);
-  });
-
+    const filter = new ChannelPayloadFilter({ selector:['#header ul li:last-child', '#header ul li:first-child'] })
+    const filterVal = filter(payload)
+    expect(filterVal).to.eq(true)
+  })
 
   it('Selectors array as first prop contains match but no data', () => {
-    let filter = new ChannelPayloadFilter(['#header ul li:last-child', '#header ul li:first-child']);
-    let filterVal = filter(payload);
-    expect(filterVal).to.eq(true);
-  });
-
+    const filter = new ChannelPayloadFilter(['#header ul li:last-child', '#header ul li:first-child'])
+    const filterVal = filter(payload)
+    expect(filterVal).to.eq(true)
+  })
 
   it('Static Data and String Selector returns true', () => {
-    let selector = '#header ul li:last-child';
-    let propFilters = {
+    const selector = '#header ul li:last-child'
+    const propFilters = {
       type:'link',
       linkType:  'external'
-    };
-    let filter = new ChannelPayloadFilter({propFilters, selector});
-    let filterVal = filter(payload);
+    }
+    const filter = new ChannelPayloadFilter({ propFilters, selector })
+    const filterVal = filter(payload)
 
-    expect(filterVal).to.eq(true);
-  });
+    expect(filterVal).to.eq(true)
+  })
 
   it('Dynamic Data and String Selector returns true', () => {
-    let selector = '#header ul li:last-child';
-    let propFilters = {
+    const selector = '#header ul li:last-child'
+    const propFilters = {
       type: (str) => str === 'link',
       linkType:  R.test(/ext.*nal/)
-    };
-    let filter = new ChannelPayloadFilter({propFilters, selector});
-    let filterVal = filter(payload);
+    }
+    const filter = new ChannelPayloadFilter({ propFilters, selector })
+    const filterVal = filter(payload)
 
-    expect(filterVal).to.eq(true);
-  });
+    expect(filterVal).to.eq(true)
+  })
 
   it('Dynamic Data with no selector returns true', () => {
-    let selector = '#header ul li:last-child';
-    let propFilters = {
+    const selector = '#header ul li:last-child'
+    const propFilters = {
       type: (str) => str === 'link',
       linkType:  R.test(/ext.*nal/)
-    };
-    let filter = new ChannelPayloadFilter({propFilters, selector});
-    let filterVal = filter(payload);
+    }
+    const filter = new ChannelPayloadFilter({ propFilters, selector })
+    const filterVal = filter(payload)
 
-    expect(filterVal).to.eq(true);
-  });
+    expect(filterVal).to.eq(true)
+  })
 
   it('Empty Filter', () => {
-    const testMode = true;
-    let filter = new ChannelPayloadFilter({testMode});
-    const {selector, propFilters} = filter;
-    const isEmpty = selector === undefined && R.isEmpty(propFilters);
-    expect(isEmpty).to.eq(true);
-  });
+    const testMode = true
+    const filter = new ChannelPayloadFilter({ testMode })
+    const { selector, propFilters } = filter
+    const isEmpty = selector === undefined && R.isEmpty(propFilters)
+    expect(isEmpty).to.eq(true)
+  })
 
   it('Empty String selector with no data', () => {
-    const testMode = true;
-    let filter = new ChannelPayloadFilter('',{},undefined,testMode);
-    const {selector, propFilters} = filter;
-    const isEmpty = R.isEmpty(selector) && R.isEmpty(propFilters);
-    expect(isEmpty).to.eq(true);
-  });
+    const testMode = true
+    const filter = new ChannelPayloadFilter('', {}, undefined, testMode)
+    const { selector, propFilters } = filter
+    const isEmpty = R.isEmpty(selector) && R.isEmpty(propFilters)
+    expect(isEmpty).to.eq(true)
+  })
 
   it('Arrays of selectors with no data', () => {
-    let filter = new ChannelPayloadFilter(['a.test', 'a.b'], {});
-    let filterVal = filter(payload);
-    expect(filterVal).to.eq(false);
-  });
+    const filter = new ChannelPayloadFilter(['a.test', 'a.b'], {})
+    const filterVal = filter(payload)
+    expect(filterVal).to.eq(false)
+  })
 
   it('Dynamic Data with no selector returns false', () => {
-    let str = '#header ul li:last-child';
-    let data = {
+    const str = '#header ul li:last-child'
+    const data = {
       type: (str) => str === 'Incorrect',
       linkType:  R.test(/ext.*nal/)
-    };
-    let filter = new ChannelPayloadFilter(undefined, data);
-    let filterVal = filter(payload);
-    expect(filterVal).to.eq(false);
-  });
+    }
+    const filter = new ChannelPayloadFilter(undefined, data)
+    const filterVal = filter(payload)
+    expect(filterVal).to.eq(false)
+  })
 
   it('False array and false dynamic data', () => {
-    let str = '#header ul li:last-child';
-    let data = {
+    const str = '#header ul li:last-child'
+    const data = {
       type: (str) => str === 'Incorrect',
       linkType:  R.test(/ext.*nal/)
-    };
-    let filter = new ChannelPayloadFilter(['', '#header ul li:first-child'], data);
-    let filterVal = filter(payload);
+    }
+    const filter = new ChannelPayloadFilter(['', '#header ul li:first-child'], data)
+    const filterVal = filter(payload)
 
-    expect(filterVal).to.eq(false);
-  });
-});
+    expect(filterVal).to.eq(false)
+  })
+})

package/src/tests/utils/channel-data-packet-generator.unused.js

@@ -1,119 +1,95 @@
-const {expect, assert} = require('chai');
-const R = require('ramda');
-import {ChannelPayloadToTestFilters} from '../mocks/channel-payload-data';
-import {ChannelDataPacketGenerator} from '../../spyne/utils/channel-data-packet-generator';
-import {ChannelDataPacket} from '../../spyne/utils/channel-data-packet';
+import { ChannelPayloadToTestFilters } from '../mocks/channel-payload-data'
+import { ChannelDataPacketGenerator } from '../../spyne/utils/channel-data-packet-generator'
+import { ChannelDataPacket } from '../../spyne/utils/channel-data-packet'
+const { expect, assert } = require('chai')
+const R = require('ramda')
 
 describe('should test the ChannelDataPacketGenerator', () => {
-
   it('should test the packet geneator', () => {
+    const packetGenerator = new ChannelDataPacketGenerator()
 
-    const packetGenerator = new ChannelDataPacketGenerator();
-
-    //console.log('packet gen is ',{ChannelPayloadToTestFilters})
-
-
-    return true;
+    // console.log('packet gen is ',{ChannelPayloadToTestFilters})
 
-  });
+    return true
+  })
 
-  it('should create a custom label for the map location', ()=>{
-    const packetLabel = ChannelDataPacketGenerator.createLabel();
-    const isValidString = /^(\w)+$/.test(packetLabel);
-    expect(isValidString).to.be.true;
+  it('should create a custom label for the map location', () => {
+    const packetLabel = ChannelDataPacketGenerator.createLabel()
+    const isValidString = /^(\w)+$/.test(packetLabel)
+    expect(isValidString).to.be.true
   })
 
-  it('should create a timestamp',()=>{
-    const timestamp = ChannelDataPacketGenerator.createTimeStamp();
-    expect(timestamp).to.be.a('number');
+  it('should create a timestamp', () => {
+    const timestamp = ChannelDataPacketGenerator.createTimeStamp()
+    expect(timestamp).to.be.a('number')
   })
 
-  it('should create an empty unpacked data file', ()=>{
-    const unpackedDataArr = ChannelDataPacketGenerator.createUnpackedDataArr(ChannelPayloadToTestFilters);
-    expect(unpackedDataArr).to.be.a('array');
+  it('should create an empty unpacked data file', () => {
+    const unpackedDataArr = ChannelDataPacketGenerator.createUnpackedDataArr(ChannelPayloadToTestFilters)
+    expect(unpackedDataArr).to.be.a('array')
   })
 
-  it('should allow for predicate test filter on packed data ',()=>{
-    const map = new Map();
-    const label = ChannelDataPacketGenerator.createLabel();
-    map.set(label, ChannelPayloadToTestFilters);
+  it('should allow for predicate test filter on packed data ', () => {
+    const map = new Map()
+    const label = ChannelDataPacketGenerator.createLabel()
+    map.set(label, ChannelPayloadToTestFilters)
 
-    const filterGateway = ChannelDataPacketGenerator.createFilterGateway(label, map);
-    const pred = R.propEq('CHANNEL_ROUTE_CHANGE_EVENT', 'action');
+    const filterGateway = ChannelDataPacketGenerator.createFilterGateway(label, map)
+    const pred = R.propEq('CHANNEL_ROUTE_CHANGE_EVENT', 'action')
 
     const isCorrectAction = filterGateway(pred)
 
-    expect(isCorrectAction).to.be.true;
-
+    expect(isCorrectAction).to.be.true
   })
 
-  it('should create data packet ',()=>{
-    const channelDataPacketGen = new ChannelDataPacketGenerator();
-
-    console.time('initPacket');
-    const channelDataPacket = channelDataPacketGen.createDataPacket(ChannelPayloadToTestFilters, ['channelName', 'action']);
-      //console.log('channel data packet ',channelDataPacket.props)
-    console.timeEnd('initPacket');
+  it('should create data packet ', () => {
+    const channelDataPacketGen = new ChannelDataPacketGenerator()
 
-    //console.log("CHANNEL DATA ALL ",channelDataPacket);
-    channelDataPacket.unPacked = true;
-    //console.log("CHANNEL DATA ALL 2 ",channelDataPacket.srcElement);
-
-
-    return true;
+    console.time('initPacket')
+    const channelDataPacket = channelDataPacketGen.createDataPacket(ChannelPayloadToTestFilters, ['channelName', 'action'])
+    // console.log('channel data packet ',channelDataPacket.props)
+    console.timeEnd('initPacket')
 
+    // console.log("CHANNEL DATA ALL ",channelDataPacket);
+    channelDataPacket.unPacked = true
+    // console.log("CHANNEL DATA ALL 2 ",channelDataPacket.srcElement);
 
+    return true
   })
 
+  it('should create a stripped down unpacked data obj', () => {
+    const obj = {
+      type :  'dog',
+      says : 'woof'
+    }
 
+    const obj2 = {
+      type : 'cat',
+      says : 'meow',
+      _unpacked : false,
+      loc : 'dog'
 
-  it('should create a stripped down unpacked data obj', ()=>{
-
-      var obj = {
-        'type' :  'dog',
-        'says' : 'woof'
-      }
-
-      var obj2 = {
-        'type' : 'cat',
-        'says' : 'meow',
-        '_unpacked' : false,
-        'loc' : 'dog'
-
-
-
-      }
-
-      Object.defineProperty(obj2, 'unpacked', {
-
-        get: ()=>obj2._unpacked,
-        set: (b) => {
-          if(b===true){
-            obj2.type = window[obj2.loc].type;
-            obj2.says = window[obj2.loc].says;
-            obj2._unpacked = b;
-          }
+    }
 
+    Object.defineProperty(obj2, 'unpacked', {
 
+      get: () => obj2._unpacked,
+      set: (b) => {
+        if (b === true) {
+          obj2.type = window[obj2.loc].type
+          obj2.says = window[obj2.loc].says
+          obj2._unpacked = b
         }
+      }
 
+    })
 
-      })
-
-    window['dog'] = obj;
-
-
-      //console.log(' both objs is ',window.dog, obj2);
-      obj2.unpacked = true;
-   // console.log(' both objs is ',window.dog, obj2);
-
+    window.dog = obj
 
-      return true;
+    // console.log(' both objs is ',window.dog, obj2);
+    obj2.unpacked = true
+    // console.log(' both objs is ',window.dog, obj2);
 
+    return true
   })
-
-
-
-
-
-});
+})

package/src/tests/utils/channel-fetch-util.test.js

@@ -1,20 +1,20 @@
-import { ChannelFetchUtil } from '../../spyne/utils/channel-fetch-util';
+import { ChannelFetchUtil } from '../../spyne/utils/channel-fetch-util'
 
 describe('ChannelFetchUtil Tests', () => {
   const mapFn = (p) => {
-    console.log('mapping fetched data ', p);
-    return p;
-  };
+    console.log('mapping fetched data ', p)
+    return p
+  }
 
-  let url = 'https://jsonplaceholder.typicode.com/posts/1';
+  const url = 'https://jsonplaceholder.typicode.com/posts/1'
 
-  let props = {
+  const props = {
     mapFn,
     url,
     method: 'GET'
-  };
+  }
 
-  let propsPost = {
+  const propsPost = {
     mapFn,
     url,
     method: 'POST',
@@ -24,109 +24,107 @@ describe('ChannelFetchUtil Tests', () => {
       body: 'bar',
       userId: 1
     }
-  };
+  }
 
-  let propsWBodyAsString = {
+  const propsWBodyAsString = {
     url,
     method: 'POST',
     body: 'bar'
-  };
+  }
 
-  let propsGetStringified = {
-    'method': 'GET',
-    'url': 'https://jsonplaceholder.typicode.com/posts/1'
-  };
+  const propsGetStringified = {
+    method: 'GET',
+    url: 'https://jsonplaceholder.typicode.com/posts/1'
+  }
 
-  let propsStringified = {
-    'body': '{"id":101,"title":"foo","body":"bar","userId":1}',
-    'method': 'POST',
-    'url': 'https://jsonplaceholder.typicode.com/posts/1'
-  };
+  const propsStringified = {
+    body: '{"id":101,"title":"foo","body":"bar","userId":1}',
+    method: 'POST',
+    url: 'https://jsonplaceholder.typicode.com/posts/1'
+  }
+
+  // const baseServerOptions = { method: 'GET', headers: {  "Accept": "application/json, text/plain, */*" } };
 
-  const baseServerOptions = { method: 'GET', headers: {  "Accept": "application/json, text/plain, */*" } };
+  const baseServerOptions = ChannelFetchUtil.baseOptions()
 
   describe('stringify body method', () => {
     it('should convert body object to string', () => {
-      let bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(propsPost);
-      bodyStr = R.omit(['mapFn'], bodyStr);
-      expect(bodyStr).to.deep.equal(propsStringified);
-    });
+      let bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(propsPost)
+      bodyStr = R.omit(['mapFn'], bodyStr)
+      expect(bodyStr).to.deep.equal(propsStringified)
+    })
 
     it('should not parse body when its a string', () => {
-      let bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(propsWBodyAsString);
+      const bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(propsWBodyAsString)
 
-      expect(bodyStr).to.deep.equal(propsWBodyAsString);
-    });
+      expect(bodyStr).to.deep.equal(propsWBodyAsString)
+    })
 
     it('should not add body param if its missing', () => {
-      let bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(props);
-      bodyStr = R.omit(['mapFn'], bodyStr);
-      expect(bodyStr).to.deep.equal(propsGetStringified);
-    });
-  });
+      let bodyStr = ChannelFetchUtil.stringifyBodyIfItExists(props)
+      bodyStr = R.omit(['mapFn'], bodyStr)
+      expect(bodyStr).to.deep.equal(propsGetStringified)
+    })
+  })
 
   describe('create a new fetch util', () => {
-    let subscriber = (data) => console.log('data retruned ', data);
-    let p = R.clone(props);
+    const subscriber = (data) => console.log('data retruned ', data)
+    const p = R.clone(props)
     // p.responseType = 'text';
 
     // console.log("PROPS P",p);
 
-    let channelFetchUtil = new ChannelFetchUtil(p, subscriber, true);
+    const channelFetchUtil = new ChannelFetchUtil(p, subscriber, true)
 
     it('should return correct server option', () => {
-      let serverOptions = R.omit(['mapFn'], channelFetchUtil.serverOptions);
-      expect(serverOptions).to.deep.equal(baseServerOptions);
-    });
+      const serverOptions = R.omit(['mapFn'], channelFetchUtil.serverOptions)
+      expect(serverOptions).to.deep.equal(baseServerOptions)
+    })
 
     it('should return correct response type', () => {
-      expect(channelFetchUtil.responseType).to.equal('json');
-    });
+      expect(channelFetchUtil.responseType).to.equal('json')
+    })
 
     it('should return correct url', () => {
-      expect(channelFetchUtil.url).to.equal(url);
-    });
-  });
-
+      expect(channelFetchUtil.url).to.equal(url)
+    })
+  })
 
-/*  describe('it should fetch an image', ()=>{
+  /*  describe('it should fetch an image', ()=>{
     let imgUrl = "http://localhost/spyne/src/tests/mocks/imgs/goat.jpg";
 
-
     it ('should return the image', ()=>{
       let channelFetchUtil = new ChannelFetchUtil({url:imgUrl, responseType:'blob'}, subscriber);
       let subscriber = (data) => console.log('data retruned ', data);
 
-
       return true;
     })
 
-
-  });*/
+  }); */
 
   describe('fetch util updates method to POST from GET when body exists', () => {
-    let subscriber = (data) => console.log('data retruned ', data);
-    let p = R.omit(['method', 'mapFn'], props);
-    p.responseType = 'text';
-    p.body = { foo:'bar' };
+    const subscriber = (data) => console.log('data retruned ', data)
+    const p = R.omit(['method', 'mapFn'], props)
+    p.responseType = 'text'
+    p.body = { foo:'bar' }
 
-    let channelFetchUtil = new ChannelFetchUtil(p, subscriber, true);
+    const channelFetchUtil = new ChannelFetchUtil(p, subscriber, true)
 
     it('should return correct server option', () => {
-      let serverOptions = R.omit(['mapFn'], channelFetchUtil.serverOptions);
-      return true;
-    });
+      const serverOptions = R.omit(['mapFn'], channelFetchUtil.serverOptions)
+      return true
+    })
 
     it('should return correct response type', () => {
-      expect(channelFetchUtil.responseType).to.equal('text');
-    });
+      expect(channelFetchUtil.responseType).to.equal('text')
+    })
 
     it('should return correct url', () => {
-      expect(channelFetchUtil.url).to.equal(url);
-    });
+      expect(channelFetchUtil.url).to.equal(url)
+    })
 
     it('should return default mapFn', () => {
-      expect(channelFetchUtil.mapFn).to.be.a('function');
-    });
-  });
-});
+      expect(channelFetchUtil.mapFn).to.be.a('function')
+    })
+  })
+})

package/src/tests/utils/frp-tools.test.js

@@ -1,36 +1,36 @@
-import * as R from 'ramda';
-import { findStrOrRegexMatchStr } from '../../spyne/utils/frp-tools';
-import { ViewStreamHashMethodsObj } from '../mocks/utils-data';
+import * as R from 'ramda'
+import { findStrOrRegexMatchStr } from '../../spyne/utils/frp-tools'
+import { ViewStreamHashMethodsObj } from '../mocks/utils-data'
 
-const hashMethodsObj = ViewStreamHashMethodsObj;
+const hashMethodsObj = ViewStreamHashMethodsObj
 
 describe('functional reactive methods tests', () => {
-  let methodStrFound = 'UI_EVENT_CLICK';
-  let methodRegExFound = 'UI_EVENT_FOCUS';
-  let methodNotFound = 'UI_EVEN1T_FOCUS33';
+  const methodStrFound = 'UI_EVENT_CLICK'
+  const methodRegExFound = 'UI_EVENT_FOCUS'
+  const methodNotFound = 'UI_EVEN1T_FOCUS33'
 
   describe('should find first string match from regex', () => {
-    let findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodStrFound);
+    const findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodStrFound)
     // console.log('str found ', findMethodName,methodStrFound );
 
-    expect(findMethodName).to.equal(methodStrFound);
-  });
+    expect(findMethodName).to.equal(methodStrFound)
+  })
 
   describe('should not find the String, but the regex', () => {
-    let findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodRegExFound);
+    const findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodRegExFound)
 
     // console.log('regex found ', findMethodName, methodRegExFound );
-    expect(findMethodName).to.equal('UI_EVENT_.*');
-  });
+    expect(findMethodName).to.equal('UI_EVENT_.*')
+  })
 
   describe('should not find the String, or the regex', () => {
-    let findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodNotFound);
+    const findMethodName = findStrOrRegexMatchStr(hashMethodsObj, methodNotFound)
     // console.log('neither str or regex found ', findMethodName, methodNotFound );
     // console.log(' -------- ');
-    expect(findMethodName).to.equal(undefined);
-  });
+    expect(findMethodName).to.equal(undefined)
+  })
 
   describe('should pull in closure args and test for local match', () => {
-    return true;
-  });
-});
+    return true
+  })
+})