spyne 0.14.8 → 0.17.3

package/src/tests/mocks/utils-data.js

@@ -13,6 +13,7 @@ const SpyneConfigData = {
     },
 
     ROUTE: {
+      routeNamesArr: ['pageId', '', 'imageNum', 'author', 'photogNum', 'pixels'],
       paramsArr: ['pageId', '', 'imageNum', 'author', 'photogNum'],
       type: 'slash', /* "slash", "query" */
       isHash: false,
@@ -24,8 +25,23 @@ const SpyneConfigData = {
           'page-one': {
             'routePath': {
               'routeName': 'imageNum',
+              "work" : {
+                'routePath': {
+                  'routeName': 'author',
+                  'hemingway': 'hemingway'
+                }
+                },
               'routePath': {
-                'routeName': 'author'
+                'routeName': 'author',
+                'hemingway': 'hemingway'
+              }
+            }
+          },
+          'page-one-up': {
+            'routePath': {
+              'routeName': 'imageNum',
+              'routePath': {
+                'routeName': 'pixels'
               }
             }
           },
@@ -36,7 +52,8 @@ const SpyneConfigData = {
           },
           'page-.*': {
             'routePath': {
-              'routeName': 'randomNum'
+              'routeName': 'randomNum',
+              "thirty-two" : "32"
             }
           }
         }
@@ -73,6 +90,7 @@ const routeConfigWithRegexOverride = {
   'regexTokens': {
     '^$|index.html': ''
   },
+  'routeNamesArr' : ['pageId', 'section', 'menuItem'],
   'paramsArr': [
     '.*',
     'pageId',

package/src/tests/spyne-app.test.js

@@ -0,0 +1,27 @@
+const {expect, assert} = require('chai');
+const {SpyneApp} = require('../spyne/spyne-app');
+
+describe('should run spyne app tests', () => {
+     before(()=>{
+
+        //SpyneApp.init();
+
+     })
+
+
+  it('spyne app constructor should exist', () => {
+    const constructorName = SpyneApp.constructor.name;
+    expect(constructorName).to.equal('SpyneApplication');
+    return true;
+  });
+
+  it('should return warn if trying to initialize spyne application again', ()=>{
+
+    const warnStr = "The Spyne Application has already been initialized!";
+    const spyneAppInit2 = SpyneApp.init({}, true);
+
+    //console.log('second init returns string ',{spyneAppInit2, warnStr})
+    expect(spyneAppInit2).to.equal(warnStr);
+  })
+
+});

package/src/tests/spyne-plugin.test.js

@@ -0,0 +1,49 @@
+//import {SpyneApp} from '../spyne/spyne';
+//const {SpyneApp} = require('../spyne/spyne');
+const {expect, assert} = require('chai');
+const {SpynePlugin} = require('../spyne/spyne-plugins.js');
+
+const name = 'mySpynePlugin';
+const config = {debug:true};
+
+describe('should test use of spyne plugin', () => {
+  const baseConfig = {debug:false};
+  beforeEach(()=>{
+
+
+  })
+
+
+  it('spyne plugin should exist', () => {
+    //console.log('spyne plugin1  is ',spyneApp);
+
+    return true;
+  // expect(SpynePlugin).to.exist;
+
+  });
+
+/*
+  it('should get or create new spyne app', ()=>{
+    const spyneApp = SpynePlugin.getSpyneApp({name, config})
+     console.log("HERE IS ",{name, config, spyneApp})
+
+    //console.log('spune app is ',spyneApp.constructor.name)
+    expect(spyneApp.constructor.name).to.equal('SpyneApp');
+  })
+
+*/
+
+/*  it('should set the plugin name', ()=>{
+    const spynePluginSetConfig =  SpynePlugin.updateSpyneConfig(spyneApp, name, config);
+
+   expect(spynePluginSetConfig).to.deep.equal(config);
+
+  })
+
+  it('should check if spyne plugin name already exists', ()=>{
+    const config1 =  SpynePlugin.updateSpyneConfig(spyneApp, name, config);
+    const configDupe =  SpynePlugin.updateSpyneConfig(spyneApp, name, config);
+    expect(configDupe).to.be.false;
+  })*/
+
+});

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

@@ -3,6 +3,7 @@ import { internalViewStreamPayload, internvalRouteChannelPayload } from '../mock
 import { spyneDocsDomStr } from '../mocks/spyne-docs.mocks';
 
 import * as R from 'ramda';
+import {UnsubscriptionError} from 'rxjs';
 internalViewStreamPayload.srcElement.el = document.querySelector('.has-svg.github');
 describe('channel action filter', () => {
   let payload = internalViewStreamPayload;
@@ -23,7 +24,7 @@ describe('channel action filter', () => {
     document.body.removeChild(document.getElementById('app'));
   });
   it('Create a new ChannelPayloadFilter', () => {
-    let filter = new ChannelPayloadFilter();
+    let filter = new ChannelPayloadFilter({test:true});
     let filterConstructor = filter.constructor.name;
     return filterConstructor.should.equal('Function');
   });
@@ -41,6 +42,14 @@ describe('channel action filter', () => {
     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);
+  });
+
+
   it('Static Data and String Selector returns true', () => {
     let selector = '#header ul li:last-child';
     let propFilters = {
@@ -78,21 +87,23 @@ describe('channel action filter', () => {
   });
 
   it('Empty Filter', () => {
-    let filter = new ChannelPayloadFilter();
-    let filterVal = filter(payload);
-    //console.log("EMPTY STRING ",filterVal);
-    expect(filterVal).to.eq(false);
+    const testMode = true;
+    let 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', () => {
-    let filter = new ChannelPayloadFilter('');
-    let filterVal = filter(payload);
-    //console.log("EMPTY STRING NO DATA",payload);
-    expect(filterVal).to.eq(false);
+    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);
   });
 
-  it('Empty Arrays of selectors with no data', () => {
-    let filter = new ChannelPayloadFilter(['', '#header ul li:first-child']);
+  it('Arrays of selectors with no data', () => {
+    let filter = new ChannelPayloadFilter(['a.test', 'a.b'], {});
     let filterVal = filter(payload);
     expect(filterVal).to.eq(false);
   });

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

@@ -0,0 +1,119 @@
+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';
+
+describe('should test the ChannelDataPacketGenerator', () => {
+
+  it('should test the packet geneator', () => {
+
+    const packetGenerator = new ChannelDataPacketGenerator();
+
+    //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 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 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('action', 'CHANNEL_ROUTE_CHANGE_EVENT');
+
+    const isCorrectAction = filterGateway(pred)
+
+    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');
+
+    //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', ()=>{
+
+      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;
+          }
+
+
+        }
+
+
+      })
+
+    window['dog'] = obj;
+
+
+      //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/plugins-methods.test.js

@@ -0,0 +1,103 @@
+const {expect, assert} = require('chai');
+import {SpynePluginsMethods} from '../../spyne/utils/spyne-plugins-methods';
+
+
+
+const spynePluginMethods = new SpynePluginsMethods();
+
+
+const methodsObj = {
+  myFn1: ()=>{
+    return 'first method value'
+  },
+
+  myFn2: ()=>{
+    return 'second method vaue'
+  }
+
+}
+
+const dupeMethods = {
+
+  myFn1: ()=>{
+    return 'this is a dupe method'
+  },
+
+  myFn4: ()=>{
+    return 'second method vaue'
+  }
+
+
+
+}
+
+
+const methodsObjWrong = {
+  myStr1: "This should be a valid method.",
+
+  myFn3: ()=>{
+    return 'second method vaue'
+  }
+}
+
+
+
+
+const methodsArr = [
+  {
+    myFn1: ()=>{
+      return 'first method value'
+    }
+  }
+]
+
+
+
+//console.log('plugin methods1 is ',{spynePluginMethods})
+
+describe('should test spyne plugins methods', () => {
+
+  it('should test that SpynePluginsMethods exists', () => {
+
+    expect(spynePluginMethods).to.exist;
+
+  });
+
+  it('should get the plugin object', ()=>{
+   const pluginsMethodObj = spynePluginMethods.pluginMethodsObj
+    expect(pluginsMethodObj).to.be.an('object');
+
+  })
+
+  it('should check if methodsObj is valid obj', ()=>{
+    const warnStr = spynePluginMethods.addMethods(methodsArr, true);
+    expect(warnStr).to.be.a('string');
+  })
+
+  it('should return error for non method vals', ()=>{
+    const warnStr = spynePluginMethods.addMethods(methodsObjWrong, true);
+    expect(warnStr).to.be.a('string');
+  })
+
+
+
+  it('should add methods from key value pairs', ()=>{
+
+    spynePluginMethods.addMethods(methodsObj);
+
+    const pluginMethodsObj = spynePluginMethods.pluginMethodsObj;
+    const firstMethodVal =pluginMethodsObj.myFn1()
+    expect(firstMethodVal).to.equal(methodsObj.myFn1());
+
+  })
+
+
+  it('should capture already created methods', ()=>{
+
+    const warnStr = spynePluginMethods.addMethods(dupeMethods, true);
+    expect(warnStr).to.be.a('string');
+
+  })
+
+
+});

package/src/tests/utils/spyne-app-properties.test.js

@@ -0,0 +1,11 @@
+const {expect, assert} = require('chai');
+
+describe('root test', () => {
+
+  it('should run shell tests', () => {
+
+    return true;
+
+  });
+
+});

package/src/tests/views/dom-el-selectors.test.js

@@ -129,7 +129,7 @@ describe('Dom Item Selector', () => {
     let el$ =   ViewStreamSelector("ul#my-list");
     let el1 = el.querySelector('li:nth-child(1)');
     let liList = el$('li');
-    liList.setActiveItem('bar','li:nth-child(551)');
+    liList.setActiveItem('bar','li:nth-child(5)');
     let hasBarClassBool = el1.classList.contains('bar');
     expect(hasBarClassBool).to.eq(false);
   });

package/webpack.config.js

@@ -2,7 +2,13 @@ const path = require('path');
 const webpack = require('webpack');
 const PACKAGE = require('./package');
 const version = PACKAGE.version;
-const env = require('yargs').argv.env; // use --env with webpack 2
+const getEnv = ()=>{
+  const npmCommand = process.env.npm_lifecycle_script;
+  return String(npmCommand).replace(/^(webpack.*--env)(\s)*(\w+)(.*)$/gm, "$3");
+}
+const env = getEnv();
+
+
 const libraryName = 'spyne';
 let moduleRulesArr = [];
 let devToolValue = 'eval-source-map';
@@ -20,14 +26,18 @@ const loaderOptionsPlugin = new webpack.LoaderOptionsPlugin({ options: {
 });
 
 let bannerPlugin = new webpack.BannerPlugin({
-    banner: `spynejs ${version}\nhttps://sypnejs.org\n(c) 2017-present Frank Batista`
+    banner: `spynejs ${version}\nhttps://sypnejs.org\n(c) 2017-present Frank Batista`,
+    entryOnly:true
 })
 
+//console.log("ENVI S HERE ===========",env);
+
+
 let spynePlugins = [loaderOptionsPlugin];
 
 if (env === 'build') {
   outputFile = libraryName + '.min.js';
-  devToolValue = 'none';
+  devToolValue = false;
   externalsArr = [
     WebpackRxjsExternals(),
     {ramda : {
@@ -37,9 +47,9 @@ if (env === 'build') {
         root: 'R'
       }}
   ];
-} else {
+} else if(env === 'dev') {
   outputFile = libraryName + '.js';
-   moduleRulesArr.push(
+/*   moduleRulesArr.push(
       {
         test: /(\.js)$/,
         loader: 'babel-loader',
@@ -60,22 +70,16 @@ if (env === 'build') {
         exclude: /(node_modules)/
       }
 
-  )
+  )*/
 }
 
-console.log("CONFIG IS ",process.env.BABEL_ENV );
+//console.log("CONFIG IS ",process.env.BABEL_ENV );
 
 
 const config = {
   entry: path.join(__dirname, '/src/spyne/spyne.js'),
-  devtool: '',
-  output: {
-    path: path.join(__dirname, '/lib'),
-    filename: outputFile,
-    library: 'spyne',
-    libraryTarget:  'umd',
-    umdNamedDefine: true
-  },
+  devtool: false,
+
 
 
   externals: externalsArr,
@@ -89,5 +93,16 @@ const config = {
   },
   plugins: spynePlugins
 };
+//console.log("ENV IS ============ ",env);
+
+if (env!==undefined){
+  config['output'] = {
+    path: path.join(__dirname, '/lib'),
+        filename: outputFile,
+        library: 'spyne',
+        libraryTarget:  'umd',
+        umdNamedDefine: true
+  };
+}
 
 module.exports = config;