@girders-elements/core/dist/es5/effect/__tests__/effects.js

Girders Elements is an architectural framework that assists with building data-driven apps with React or React Native.

'use strict';var _slicedToArray=function(){function sliceIterator(arr,i){var _arr=[];var _n=true;var _d=false;var _e=undefined;try{for(var _i=arr[typeof Symbol==='function'?Symbol.iterator:'@@iterator'](),_s;!(_n=(_s=_i.next()).done);_n=true){_arr.push(_s.value);if(i&&_arr.length===i)break;}}catch(err){_d=true;_e=err;}finally{try{if(!_n&&_i["return"])_i["return"]();}finally{if(_d)throw _e;}}return _arr;}return function(arr,i){if(Array.isArray(arr)){return arr;}else if((typeof Symbol==='function'?Symbol.iterator:'@@iterator')in Object(arr)){return sliceIterator(arr,i);}else{throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();

var _immutable=require('immutable');

var _action=require('../../action');var actions=_interopRequireWildcard(_action);
var _subsystem=require('../../subsystem');var Subsystem=_interopRequireWildcard(_subsystem);
var _kernel=require('../../kernel');var Kernel=_interopRequireWildcard(_kernel);
var _=require('..');var _2=_interopRequireDefault(_);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj};}function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj;}else{var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key];}}newObj.default=obj;return newObj;}}

describe('effects API',function(){var _this=this;
var data=(0,_immutable.fromJS)({
element1:{
element2:{
element3:{
kind:['article','specific']},

kind:['container']},

kind:['container']},

kind:'root'});


var app=Subsystem.create(function(){return{
name:'app'};});var


effect=app.effect;

describe('Effects',function(){
var specificEffect=jest.fn();
var specificEffect2=jest.fn();
var specificEffect3=jest.fn();
var articleEffect=jest.fn();
var componentEffect=jest.fn();

afterEach(function(){
;[
specificEffect,
specificEffect2,
specificEffect3,
articleEffect,
componentEffect].
forEach(function(m){return m.mockClear();});
});



effect.register(['article'],'mark',function _callee(context,action){return regeneratorRuntime.async(function _callee$(_context){while(1){switch(_context.prev=_context.next){case 0:_context.next=2;return regeneratorRuntime.awrap(
sleep(50));case 2:return _context.abrupt('return',
function(el){return el.set('marked',action.type);});case 3:case'end':return _context.stop();}}},null,_this);});


effect.forKind(['article','specific'],function(effects){
effects.register('toggle',specificEffect);
effects.register('toggle2',specificEffect2);
effects.register('toggle3',specificEffect3);

effects.register('noop',function _callee2(){return regeneratorRuntime.async(function _callee2$(_context2){while(1){switch(_context2.prev=_context2.next){case 0:case'end':return _context2.stop();}}},null,_this);});
effects.register('noop2',function(){});
});

effect.register(['article'],'toggle',articleEffect);

effect.register(['container'],'.toggle',componentEffect);

effect.register(['container'],'fireOnSub',function _callee3(context){return regeneratorRuntime.async(function _callee3$(_context3){while(1){switch(_context3.prev=_context3.next){case 0:
context.focusOn(['element3']).dispatch({type:'toggle3'});case 1:case'end':return _context3.stop();}}},null,_this);});


describe('effect context',function(){
var kernel=Kernel.create([_2.default,app],data,{});

test('normal action',function _callee4(){var _specificEffect$mock$,context,action;return regeneratorRuntime.async(function _callee4$(_context4){while(1){switch(_context4.prev=_context4.next){case 0:
kernel.
focusOn(['element1','element2','element3']).
dispatch({type:'toggle'});_context4.next=3;return regeneratorRuntime.awrap(

sleep(50));case 3:

expect(specificEffect).toHaveBeenCalled();
expect(specificEffect2).not.toHaveBeenCalled();_specificEffect$mock$=_slicedToArray(
specificEffect.mock.calls[
specificEffect.mock.calls.length-1],2),context=_specificEffect$mock$[0],action=_specificEffect$mock$[1];


expect(action.type).toEqual('toggle');
expect(actions.actionMeta(action).keyPath).toEqual([
'element1',
'element2',
'element3']);

expect(context.query().get('kind')).toEqualI(
_immutable.List.of('article','specific'));


context.dispatch({type:'toggle2'});_context4.next=12;return regeneratorRuntime.awrap(

sleep(50));case 12:

expect(specificEffect2).toHaveBeenCalled();case 13:case'end':return _context4.stop();}}},null,_this);});


test('global action',function _callee5(){var _componentEffect$mock,context,action,_componentEffect$mock2,context2,action2;return regeneratorRuntime.async(function _callee5$(_context5){while(1){switch(_context5.prev=_context5.next){case 0:
kernel.
focusOn(['element1','element2','element3']).
dispatch({type:'.toggle'});

expect(componentEffect).toHaveBeenCalled();_componentEffect$mock=_slicedToArray(
componentEffect.mock.calls[0],2),context=_componentEffect$mock[0],action=_componentEffect$mock[1];

expect(context.query().get('kind')).toEqualI(_immutable.List.of('container'));
expect(actions.actionMeta(action).keyPath).toEqual([
'element1',
'element2',
'element3']);

expect(context.query()._keyPath).toEqual(['element1','element2']);
expect(action.type).toEqual('.toggle');

kernel.focusOn(['element1']).dispatch({type:'.toggle'});_context5.next=10;return regeneratorRuntime.awrap(

sleep(50));case 10:_componentEffect$mock2=_slicedToArray(

componentEffect.mock.calls[1],2),context2=_componentEffect$mock2[0],action2=_componentEffect$mock2[1];
expect(context2.query()._keyPath).toEqual(['element1']);
expect(action2.type).toEqual('.toggle');case 13:case'end':return _context5.stop();}}},null,_this);});


describe('action on sub-element',function _callee6(){return regeneratorRuntime.async(function _callee6$(_context6){while(1){switch(_context6.prev=_context6.next){case 0:
kernel.focusOn(['element1','element2']).dispatch({type:'fireOnSub'});_context6.next=3;return regeneratorRuntime.awrap(

sleep(50));case 3:

expect(specificEffect3).toHaveBeenCalled();case 4:case'end':return _context6.stop();}}},null,_this);});

});

describe("Effect's return value",function(){
var kernel=Kernel.create([_2.default,app],data,{});

test('Effect can return an updating fn state => newState',function _callee7(){var focus;return regeneratorRuntime.async(function _callee7$(_context7){while(1){switch(_context7.prev=_context7.next){case 0:
focus=kernel.focusOn(['element1','element2','element3']);

focus.dispatch({type:'mark'});_context7.next=4;return regeneratorRuntime.awrap(

sleep(25));case 4:

expect(focus.query().get('marked')).not.toEqual('mark');_context7.next=7;return regeneratorRuntime.awrap(

sleep(50));case 7:

expect(focus.query().get('marked')).toEqual('mark');case 8:case'end':return _context7.stop();}}},null,_this);});


test('An async effect can return undefined',function(){
var focus=kernel.focusOn(['element1','element2','element3']);

focus.dispatch({type:'noop2'});
focus.dispatch({type:'noop'});
});
});
});
});

function sleep(ms){
return new Promise(function(resolve){return setTimeout(resolve,ms);});
}