spyne 0.14.8 → 0.17.3

package/src/spyne/views/view-stream.js

@@ -1,4 +1,5 @@
 import { baseCoreMixins } from '../utils/mixins/base-core-mixins';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 //import { baseStreamsMixins } from '../utils/mixins/base-streams-mixins';
 import { deepMerge } from '../utils/deep-merge';
 import {
@@ -16,7 +17,41 @@ import { ViewStreamObservable } from '../utils/viewstream-observables';
 import {ViewStreamSelector} from './view-stream-selector';
 import { Subject, of } from 'rxjs';
 import { mergeMap, map, takeWhile, filter, tap, skip, finalize } from 'rxjs/operators';
-import {pick, compose, isNil, all, isEmpty, forEach, toLower, either, findIndex, partial, apply, test, flatten ,prop, always, lte, defaultTo, propSatisfies, allPass, curry, nth, is,slice, path, omit, ifElse, lensPath, view, clone,  mergeRight, where, equals} from 'ramda';
+import {
+  pick,
+  compose,
+  isNil,
+  all,
+  isEmpty,
+  forEach,
+  toLower,
+  either,
+  findIndex,
+  partial,
+  apply,
+  test,
+  flatten,
+  prop,
+  always,
+  lte,
+  defaultTo,
+  propSatisfies,
+  allPass,
+  curry,
+  nth,
+  is,
+  slice,
+  path,
+  omit,
+  ifElse,
+  lensPath,
+  view,
+  clone,
+  mergeRight,
+  where,
+  equals,
+  assocPath,
+} from 'ramda';
 
 const rMap = require('ramda').map;
 
@@ -36,7 +71,7 @@ export class ViewStream {
    <li>LINK['ViewStreamBroadcaster', 'view-stream-broadcaster']: Takes the nested array from the <i>BroadcastEvents</i> method and creates RxJs observables that are delegated to either the CHANNEL_UI or CHANNEL_ROUTE
    <li>LINK['ViewStreamSelector', 'view-stream-selector']: Provides selector and CSS utility methods.
    <li>LINK['ViewStreamPayload', 'view-stream-payload']: Payload format for sending data to Channels using the <i>sendInfoToChannel</i> method.
-    </ul>
+   </ul>
    *
    *
    * <h4>Rendering</h4>
@@ -166,7 +201,7 @@ export class ViewStream {
     this.sink$ = new Subject();
     const ViewClass = this.props.viewClass;
     this.view = new ViewClass(this.sink$, {}, this.props.vsid,
-      this.props.id);// new this.props.viewClass(this.sink$);
+        this.props.id);// new this.props.viewClass(this.sink$);
     this.sourceStreams = this.view.sourceStreams;
     this._rawSource$ = this.view.getSourceStream();
     this._rawSource$['viewName'] = this.props.name;
@@ -186,7 +221,7 @@ export class ViewStream {
     const elIsDomElement = compose(lte(0), defaultTo(-1), prop('nodeType'));
     const elIsRendered = el => document.body.contains(el);
     const elIsReadyBool = propSatisfies(
-      allPass([elIsRendered, elIsDomElement]), 'el');
+        allPass([elIsRendered, elIsDomElement]), 'el');
 
     if (elIsReadyBool(this.props)) {
       this.updatePropsToMatchEl();
@@ -208,11 +243,11 @@ export class ViewStream {
         actionFilter = new ChannelPayloadFilter({selector:actionFilter});
       }
       this.props.extendedSourcesHashMethods[action] = channelFn(funcStr,
-        actionFilter);
+          actionFilter);
     };
     this.addActionListeners().forEach(createExtraStatesMethod);
     this.props.hashSourceMethods = this.setSourceHashMethods(
-      this.props.extendedSourcesHashMethods);
+        this.props.extendedSourcesHashMethods);
   }
 
   /**
@@ -251,11 +286,22 @@ export class ViewStream {
       obj['$dir'] = this.$dirs.C;
       this.sourceStreams.raw$.next(obj);
     }
-    let filterPayload =  defaultTo(always(true), actionFilter);
-    if (filterPayload(p.props()) === true) {
-    //  p = omit(['dir$'],p);
+    let filterPayload = defaultTo(always(true), actionFilter);
+    const filterLabel = `filtering-${Math.floor(Math.random() * 999999)}`;
+
+    if (actionFilter !== undefined) {
+     //console.time(filterLabel);
+
+
+    }
+    if (filterPayload(p) === true) {
+      //  p = omit(['dir$'],p);
       p = omit(['$dir'], p)
-      //console.log(' payload vs ',p);
+      if (actionFilter !== undefined) {
+
+       // console.log(`pf - ${filterLabel}: `, p);
+        //console.timeEnd(filterLabel);
+      }
       runFunc(p);
       //this[str](p);
     }
@@ -280,7 +326,7 @@ export class ViewStream {
   // ====================== MAIN STREAM METHODS ==========================
   initViewStream() {
     this._source$ = this._rawSource$.pipe(map(
-      (payload) => this.onMapViewSource(payload)), takeWhile(this.notGCSTATE));
+        (payload) => this.onMapViewSource(payload)), takeWhile(this.notGCSTATE));
 
     this.initAutoMergeSourceStreams();
     this.updateSourceSubscription(this._source$, true);
@@ -320,8 +366,8 @@ export class ViewStream {
     };
 
     this.parent$ = obs.pipe(
-      filter(filterOutNullData),
-      map(checkIfDisposeOrFadeout));
+        filter(filterOutNullData),
+        map(checkIfDisposeOrFadeout));
     this.updateSourceSubscription(this.parent$, false, 'PARENT');
     this.renderAndAttachToParent(attachData);
   }
@@ -330,12 +376,12 @@ export class ViewStream {
     let filterOutNullData = (data) => data !== undefined && data.action !==
         undefined;
     let child$ = obs$.pipe(
-      filter(filterOutNullData),
-      tap(p => this.tracer('addChildStraem do ', p)),
-      map((p) => {
-        return p;
-      }),
-      finalize(p => this.onChildCompleted(child$.source)));
+        filter(filterOutNullData),
+        tap(p => this.tracer('addChildStraem do ', p)),
+        map((p) => {
+          return p;
+        }),
+        finalize(p => this.onChildCompleted(child$.source)));
     this.updateSourceSubscription(child$, true, 'CHILD');
   }
 
@@ -360,6 +406,8 @@ export class ViewStream {
     return childCompletedData;
   }
 
+
+
   initAutoMergeSourceStreams() {
     // ====================== SUBSCRIPTION SOURCE =========================
     let subscriber = {
@@ -373,6 +421,7 @@ export class ViewStream {
     //  =====================================================================
     // ========== METHODS TO CHECK FOR WHEN TO COMPLETE THE STREAM =========
     let completeAll = () => {
+
       this.props.el$ = undefined;
       this.uberSource$.complete();
       this.autoSubscriber$.complete();
@@ -395,7 +444,7 @@ export class ViewStream {
     let incrementObservablesThatCloses = () => { obsCount += 1; };
     this.autoMergeSubject$ = this.uberSource$.pipe(mergeMap((obsData) => {
       let branchObservable$ = obsData.observable.pipe(filter(
-        (p) => p !== undefined && p.action !== undefined), map(p => {
+          (p) => p !== undefined && p.action !== undefined), map(p => {
         // console.log('PAYLOAD IS ', p, this.constructor.name)
         let payload = deepMerge({}, p);
         payload.action = p.action;// addRelationToState(obsData.rel, p.action);
@@ -412,9 +461,9 @@ export class ViewStream {
     }));
     // ============================= SUBSCRIBER ==============================
     this.autoSubscriber$ = this.autoMergeSubject$
-    // .do((p) => console.log('SINK DATA ', this.constructor.name, p))
-      .pipe(filter((p) => p !== undefined && p.action !== undefined))
-      .subscribe(subscriber);
+        // .do((p) => console.log('SINK DATA ', this.constructor.name, p))
+        .pipe(filter((p) => p !== undefined && p.action !== undefined))
+        .subscribe(subscriber);
   }
 
   // ========================= MERGE STREAMS TO MAIN SUBSCRIBER =================
@@ -436,7 +485,7 @@ export class ViewStream {
     // ****USE REGEX AS PREDICATE CHECK FOR PAYLOAD.ACTION IN HASH METHODS OBJ
     // const hashAction = this.props.hashSourceMethods[payload.action];
     const hashActionStr = findStrOrRegexMatchStr(this.props.hashSourceMethods,
-      payload.action);
+        payload.action);
     const hashAction = this.props.hashSourceMethods[hashActionStr];
     // console.log('S PAYLOAD ', this.props.name, typeof (hashAction), payload);
 
@@ -489,13 +538,13 @@ export class ViewStream {
     this.openSpigot('VS_SPAWN_AND_ATTACH_TO_DOM', { attachData });
   }
 
-/*
-  attachChildToView(data) {
-    // let childRenderData = data.attachData;
-    // console.log('CHILD DATA ', this.constructor.name, childRenderData);
-    // this.openSpigot('ATTACH_CHILD_TO_SELF', {childRenderData});
-  }
-*/
+  /*
+    attachChildToView(data) {
+      // let childRenderData = data.attachData;
+      // console.log('CHILD DATA ', this.constructor.name, childRenderData);
+      // this.openSpigot('ATTACH_CHILD_TO_SELF', {childRenderData});
+    }
+  */
 
   // ===================================== EXTIRPATE METHODS =================================
   checkParentDispose(p) {
@@ -560,12 +609,14 @@ export class ViewStream {
     if (this.props !== undefined) {
       this.props.action = action;
       let data = mergeRight(this.props, obj);
+      //let data = Object.assign({}, this.props, obj);
+
       this.sink$.next(Object.freeze(data));
     }
   }
 
   static isDevMode(){
-    return path(['Spyne', 'config', 'debug'], window)===true;
+    return SpyneAppProperties.debug;
   }
 
   setAttachData(attachType, query) {
@@ -599,11 +650,12 @@ export class ViewStream {
 
   setAttachParentData(attachType, query, level) {
     query = query!=="" ? query : undefined;
+    const node = this.getParentEls(this.props.el, level);
     return {
-      node: this.getParentEls(this.props.el, level),
+      node,
       type: 'ViewStreamObservable',
       attachType,
-      query: this.props.el.parentElement.querySelector(query)
+      query: node.querySelector(query)
     };
   }
 
@@ -705,7 +757,7 @@ export class ViewStream {
 
   appendViewToParentEl(v, query, level = 1) {
     this.exchangeViewsWithChild(v,
-      this.setAttachParentData('appendChild', query, level));
+        this.setAttachParentData('appendChild', query, level));
   }
 
   /**
@@ -728,7 +780,7 @@ export class ViewStream {
    * */
   prependViewToParentEl(v, query, level = 1) {
     this.exchangeViewsWithChild(v,
-      this.setAttachParentData('prependChild', query, level));
+        this.setAttachParentData('prependChild', query, level));
   }
 
   /**
@@ -779,7 +831,12 @@ export class ViewStream {
   postRender() {
     this.beforeAfterRender();
     this.afterRender();
+
     this.onRendered();
+    const startAnimFrameAfterRendered = ()=>this.onAnimFrameAfterRendered();
+    requestAnimationFrame(startAnimFrameAfterRendered);
+
+
 
     if (this.isDevMode === true ){
       const eventsArr = this.broadcastEvents();
@@ -791,8 +848,8 @@ export class ViewStream {
     }
 
     this.viewsStreamBroadcaster = new ViewStreamBroadcaster(this.props,
-      this.broadcastEvents.bind(this));
-      this.afterBroadcastEvents();
+        this.broadcastEvents.bind(this));
+    this.afterBroadcastEvents();
   }
 
   addTraits(traits){
@@ -813,57 +870,56 @@ export class ViewStream {
 
   afterBroadcastEvents(){
 
-      if (this.isDevMode === true ){
-        const pullActionsFromList = (arr)=>arr[0];
-        const nestedActionsArr = this.addActionListeners();
-
-        let actionsArr = nestedActionsArr.map(pullActionsFromList);
+    if (this.isDevMode === true ){
+      const pullActionsFromList = (arr)=>arr[0];
+      const nestedActionsArr = this.addActionListeners();
 
-        const isValidArr = ViewStream.isValidNestedArr(nestedActionsArr);
+      let actionsArr = nestedActionsArr.map(pullActionsFromList);
 
-        if (isValidArr === false){
-          console.warn(`Spyne Warning: The array returned from addActionsListeners in ${this.props.name}, '${JSON.stringify(nestedActionsArr)}', does not appear to be properly formatted!`);
-        } else {
-          const checkForExistingMethod = (arr)=>{
-            const method = defaultTo('', arr[1]);
-            const isMethod = is(Function, this[method]);
-            if (isMethod === false){
-              console.warn(`Spyne Warning: The method in addActionListeners nested Array, '${JSON.stringify(arr)}', in ${this.props.name}, does not appear to exist!`);
-            }
+      const isValidArr = ViewStream.isValidNestedArr(nestedActionsArr);
 
+      if (isValidArr === false){
+        console.warn(`Spyne Warning: The array returned from addActionsListeners in ${this.props.name}, '${JSON.stringify(nestedActionsArr)}', does not appear to be properly formatted!`);
+      } else {
+        const checkForExistingMethod = (arr)=>{
+          const method = defaultTo('', arr[1]);
+          const isMethod = is(Function, this[method]);
+          if (isMethod === false){
+            console.warn(`Spyne Warning: The method in addActionListeners nested Array, '${JSON.stringify(arr)}', in ${this.props.name}, does not appear to exist!`);
           }
-          compose(forEach(checkForExistingMethod), defaultTo([]))(nestedActionsArr);
-        }
 
-        const delayForProxyChannelResets = ()=>{
-          if (path(['props','addedChannels'], this) !== undefined) {
-            ViewStream.checkIfActionsAreRegistered.bind(this)(this.props.addedChannels, actionsArr);
-          }
-        };
-        this.setTimeout(delayForProxyChannelResets, 500);
+        }
+        compose(forEach(checkForExistingMethod), defaultTo([]))(nestedActionsArr);
       }
+
+      const delayForProxyChannelResets = ()=>{
+        if (path(['props','addedChannels'], this) !== undefined) {
+          ViewStream.checkIfActionsAreRegistered.bind(this)(this.props.addedChannels, actionsArr);
+        }
+      };
+      this.setTimeout(delayForProxyChannelResets, 500);
+    }
   }
   static checkIfActionsAreRegistered(channelsArr=[], actionsArr){
-      //const getActionsFn = path(['Spyne', 'channels', 'getChannelActions'], window);
-      if (actionsArr.length>0){
-        const getAllActions = (a)=>{
-          const getRegisteredActionsArr = (str)=>window.Spyne.channels.getChannelActions(str);
-          let arr =  a.map(getRegisteredActionsArr);
-          return flatten(arr);
-        }
-        const checkForMatch = (strMatch) => {
-          let re = new RegExp(strMatch);
-          let actionIndex = findIndex(test(re), getAllActionsArr)
-          if (actionIndex<0){
-            let channelSyntax = channelsArr.length === 1 ? "from added channel. \nDid you forget to add the Channel to this ViewStream?" : "from added channels. \nDid you forget to add the Channel to this ViewStream?";
-            console.warn(`Spyne Warning: The action, ${strMatch}, in ${this.props.name}, does not match any of the registered actions ${channelSyntax}, ${channelsArr.join(', ')}`)
-          }
-         //  const vsnum = ()=> R.test(new RegExp(str), "CHANNEL_ROUTE_TEST_EVENT")
+    if (actionsArr.length>0){
+      const getAllActions = (a)=>{
+        const getRegisteredActionsArr = (str)=>SpyneAppProperties.getChannelActions(str);
+        let arr =  a.map(getRegisteredActionsArr);
+        return flatten(arr);
+      }
+      const checkForMatch = (strMatch) => {
+        let re = new RegExp(strMatch);
+        let actionIndex = findIndex(test(re), getAllActionsArr)
+        if (actionIndex<0){
+          let channelSyntax = channelsArr.length === 1 ? "from added channel" : "from added channels";
+          console.warn(`Spyne Warning: The action, ${strMatch}, in ${this.props.name}, does not match any of the registered actions ${channelSyntax}, ${channelsArr.join(', ')}`)
         }
-        let getAllActionsArr = getAllActions(channelsArr);
-        actionsArr.forEach(checkForMatch);
-
+        //  const vsnum = ()=> R.test(new RegExp(str), "CHANNEL_ROUTE_TEST_EVENT")
       }
+      let getAllActionsArr = getAllActions(channelsArr);
+      actionsArr.forEach(checkForMatch);
+
+    }
 
   }
 
@@ -872,11 +928,11 @@ export class ViewStream {
   }
 
   beforeAfterRender() {
-/*    let dm2 = function(el) {
-      return function(str = '') {
-        return new DomItemSelectors(el, str);
-      };
-    };*/
+    /*    let dm2 = function(el) {
+          return function(str = '') {
+            return new DomItemSelectors(el, str);
+          };
+        };*/
 
     //this.props.el$ = dm2(this.props.el);
     this.setDataVSID();
@@ -901,6 +957,17 @@ export class ViewStream {
   onRendered() {
   }
 
+  /**
+   *
+   * This method is useful to add animation classes to be called immediately after rendering.
+   *
+   */
+
+  onAnimFrameAfterRendered() {
+  }
+
+
+
 
 
   /**
@@ -919,12 +986,12 @@ export class ViewStream {
    * @example
    *
    *  broadcastEvents() {
-     *  // ADD BUTTON EVENTS AS NESTED ARRAYS
-     *  return [
-     *       ['#my-button', 'mouseover'],
-     *       ['#my-input', 'change']
-     *     ]
-     *   }
+   *  // ADD BUTTON EVENTS AS NESTED ARRAYS
+   *  return [
+   *       ['#my-button', 'mouseover'],
+   *       ['#my-input', 'change']
+   *     ]
+   *   }
    *
    *
    * */
@@ -964,9 +1031,9 @@ export class ViewStream {
   getChannel(channel) {
     let isValidChannel = c => registeredStreamNames().includes(c);
     let error = c => console.warn(
-      `channel name ${c} is not within ${registeredStreamNames}`);
+        `channel name ${c} is not within ${registeredStreamNames}`);
     let startSubscribe = (c) => {
-      let obs$ = window.Spyne.channels.getStream(c).observer;
+      let obs$ = SpyneAppProperties.channelsMap.getStream(c).observer;
 
       return obs$.pipe(takeWhile(p => this.deleted !== true));
     };// getGlobalParam('streamsController').getStream(c).observer;
@@ -991,34 +1058,32 @@ export class ViewStream {
    * let routeChannel = this.addChannel('ROUTE');
    *
    *      addActionListeners() {
-     *           return [
-     *             ['CHANNEL_ROUTE_CHANGE_EVENT', 'onMapRouteEvent']
-     *           ]
-     *       }
+   *           return [
+   *             ['CHANNEL_ROUTE_CHANGE_EVENT', 'onMapRouteEvent']
+   *           ]
+   *       }
    *
    *       onMapRouteEvent(p) {
-     *          console.log('the route value is ', p);
-     *       }
+   *          console.log('the route value is ', p);
+   *       }
    *
    *
    * */
 
   addChannel(str, skipFirst=false, sendDownStream = false, bool = false) {
 
-
-
-    if (skipFirst === true){
-
-    }
-
-
     const directionArr = sendDownStream === true ? this.$dirs.CI : this.$dirs.I;
     const mapDirection = p => {
-      let p2 = defaultTo({}, clone(p));
-      let dirObj = { $dir: directionArr };
-      return deepMerge(dirObj, p2);
+      //et p2 = defaultTo({}, clone(p));
+      let pl = p;// || {};
+      pl['$dir'] = directionArr;
+      return pl;
+      //return deepMerge(dirObj, p2);
       // Object.assign({$dir: directionArr}, clone(p))
     };
+
+
+
     const isLocalEventCheck = path(['srcElement', 'isLocalEvent']);
     const cidCheck = path(['srcElement', 'vsid']);
     const cidMatches = p => {
@@ -1041,7 +1106,7 @@ export class ViewStream {
 
 
   checkIfChannelExists(channelName) {
-    let channelExists = window.Spyne.channels.map.get(channelName) !== undefined;
+    let channelExists = SpyneAppProperties.channelsMap.testStream(channelName);
     if (channelExists !== true) {
       console.warn(`SPYNE WARNING: The ChannelPayload from ${this.props.name}, has been sent to a channel, ${channelName}, that has not been registered!`);
     }
@@ -1063,13 +1128,42 @@ export class ViewStream {
    *
    */
 
-  sendInfoToChannel(channelName, payload = {}, action = 'VIEWSTREAM_EVENT') {
+  sendInfoToChannel(channelName, pl = {}, action) {
+    const payload = pl;
+
+    let defaultToAction = defaultTo('VIEWSTREAM_EVENT');
+    const channelDefaultActionHash = {
+      CHANNEL_ROUTE: "CHANNEL_ROUTE_CHANGE_EVENT"
+    }
+    const getActionFn = compose(defaultToAction, prop(channelName))
+
+    action = action || getActionFn(channelDefaultActionHash);
+
+
     let data = { payload, action };
+
+
     data.srcElement = compose(pick(['id','vsid','class','tagName']), prop('props'))(this);
     if (this.checkIfChannelExists(channelName) === true) {
-      let obs$ = of(data);
-      return new ViewStreamPayload(channelName, obs$, data);
-    }
+      if (/CHANNEL_LIFECYCLE/.test(action)===false){
+        Object.defineProperties(data, {
+          payload: {
+            get: ()=> clone(pl)
+
+          }
+        })
+
+      }
+        let obs$ = of(data);
+        return new ViewStreamPayload(channelName, obs$, data);
+
+      }
+
+
+
+
+
+
   }
 
   tracer(...args) {
@@ -1098,8 +1192,18 @@ export class ViewStream {
 
   isLocalEvent(channelPayloadItem) {
     const itemEl = path(['srcElement', 'el'], channelPayloadItem);
-    return itemEl !== undefined &&
-        this.props.el.contains(channelPayloadItem.srcElement.el);
+    const thisEl = path(['props', 'el'], this);
+    //console.log('this el is ',{thisEl, itemEl});
+    return ViewStream.elIsDomElement(thisEl) && ViewStream.elIsDomElement(itemEl) && thisEl.contains(itemEl);
+  }
+
+  static elIsDomElement(o) {
+    if (is(String,o)){
+      o = document.querySelector(o);
+    }
+
+
+    return compose(lte(0), defaultTo(-1), prop('nodeType'))(o);
   }
 
   get attributesArray() {

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

@@ -0,0 +1,102 @@
+const {expect, assert} = require('chai');
+const {ChannelFetch} = require('../../spyne/channels/channel-fetch-class')
+
+describe('should test ChannelFetch', () => {
+  const mapFn = (p) => {
+    //console.log('mapping fetched data ', p);
+    return p;
+  };
+
+  const channelName = "CHANNEL_MY_FETCHED_DATA"
+  let url = 'https://jsonplaceholder.typicode.com/posts/1';
+
+
+  it('should return true for valid mapFn method', () => {
+    let props = {
+      mapFn,
+      url,
+      method: 'GET'
+    };
+
+    const mapMethodIsValid = ChannelFetch.validateMapMethod(props, channelName);
+    //console.log('mapFn method is valid ',{mapMethodIsValid})
+    expect(mapMethodIsValid).to.be.true;
+
+  });
+
+  it('should return true for valid map method', () => {
+    const map = mapFn;
+    let props = {
+      map,
+      url,
+      method: 'GET'
+    };
+
+    const mapMethodIsValid = ChannelFetch.validateMapMethod(props, channelName);
+    //console.log('map method is valid ',{mapMethodIsValid})
+    expect(mapMethodIsValid).to.be.true;
+
+  });
+
+  it('should return true non existing map methods', () => {
+    let props = {
+      url
+    };
+
+    const noMapMethodAdded = ChannelFetch.validateMapMethod(props, channelName);
+    //console.log('map methods not added and is valid ',{noMapMethodAdded})
+    expect(noMapMethodAdded).to.be.true;
+
+  });
+
+  it('should return false for map of wrong type', () => {
+    const map = 4;
+    let props = {
+      map,
+      url
+    };
+
+    const mapTypeIsCorrect = ChannelFetch.validateMapMethod(props, "MY_TEST_NAME", true);
+    //console.log('map methods is not of correct type added and is valid1 ',{mapTypeIsCorrect}) ;     expect(mapTypeIsCorrect).to.be.false;
+
+  });
+
+  it('should return false for mapFn of wrong type', () => {
+    const mapFn = 'my str';
+    let props = {
+      mapFn,
+      url
+    };
+
+    const mapTypeIsCorrect = ChannelFetch.validateMapMethod(props, "MY_TEST_NAME_2", true);
+    //console.log('map methods is not of correct type added and is valid2 ',{mapTypeIsCorrect}) ;     expect(mapTypeIsCorrect).to.be.false;
+
+  });
+
+  it('should return false for map of wrong type', () => {
+    const map = undefined;
+    let props = {
+      map,
+      url
+    };
+
+    const mapTypeUndefined = ChannelFetch.validateMapMethod(props, "MY_TEST_NAME", true);
+    //console.log('map methods is not of correct type added and is valid3 ',{mapTypeUndefined}) ;     expect(mapTypeUndefined).to.be.false;
+
+  });
+
+  it('should return false for mapFn of wrong type', () => {
+    const mapFn = undefined;
+    let props = {
+      mapFn,
+      url
+    };
+
+    const mapTypeUndefined = ChannelFetch.validateMapMethod(props, "MY_TEST_NAME_2", true);
+    //console.log('map methods is not of correct type added and is valid4 ',{mapTypeUndefined}) ;     expect(mapTypeUndefined).to.be.false;
+
+  });
+
+
+
+});