commands per containerId, simple push, refactoring

ios/RNNBridgeModule.m

@@ -19,6 +19,15 @@ RCT_EXPORT_METHOD(setRoot:(NSDictionary*)layout)
 	[UIApplication.sharedApplication.delegate.window makeKeyAndVisible];
 }
 
+RCT_EXPORT_METHOD(push:(NSString*)containerId layout:(NSDictionary*)layout)
+{
+	[self assertReady];
+	//TODO make this not shitty
+	UIViewController* newVc = [[RNNControllerFactory new] createRootViewController:layout];
+	id vc = [UIApplication.sharedApplication.delegate.window.rootViewController childViewControllers][0];
+	[[vc navigationController]pushViewController:newVc animated:true];
+}
+
 -(void)assertReady
 {
 	if (!RNN.instance.isReadyToReceiveCommands) {

playground/e2e/app.test.js

@@ -13,7 +13,7 @@ describe('app', () => {
     expect(elementByLabel('Hello from a function!')).toBeVisible();
   });
 
-  xit('push screen', () => {
+  it('push screen', () => {
     elementByLabel('Push').tap();
     expect(elementByLabel('Pushed screen')).toBeVisible();
   });

src/Navigation.js

@@ -4,7 +4,10 @@ import UniqueIdProvider from './adapters/UniqueIdProvider';
 
 import Store from './containers/Store';
 import ContainerRegistry from './containers/ContainerRegistry';
-import Commands from './commands/Commands';
+import AppCommands from './commands/AppCommands';
+import ContainerCommands from './commands/ContainerCommands';
+import LayoutTreeParser from './commands/LayoutTreeParser';
+import LayoutTreeCrawler from './commands/LayoutTreeCrawler';
 
 class Navigation {
   constructor() {
@@ -12,7 +15,10 @@ class Navigation {
     this.nativeEventsReceiver = new NativeEventsReceiver();
     this.uniqueIdProvider = new UniqueIdProvider();
     this.containerRegistry = new ContainerRegistry(this.store);
-    this.commands = new Commands(new NativeCommandsSender(), this.uniqueIdProvider, this.store);
+    this.layoutTreeParser = new LayoutTreeParser();
+    this.layoutTreeCrawler = new LayoutTreeCrawler(this.uniqueIdProvider, this.store);
+    this.nativeCommandsSender = new NativeCommandsSender();
+    this.appCommands = new AppCommands(this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler);
   }
 
   registerContainer(containerName, getContainerFunc) {
@@ -20,12 +26,16 @@ class Navigation {
   }
 
   setRoot(params) {
-    return this.commands.setRoot(params);
+    return this.appCommands.setRoot(params);
   }
 
   events() {
     return this.nativeEventsReceiver;
   }
+
+  on(containerId) {
+    return new ContainerCommands(containerId, this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler);
+  }
 }
 
 const singleton = new Navigation();

src/Navigation.test.js

@@ -2,12 +2,14 @@ describe('Navigation', () => {
   let Navigation;
 
   beforeEach(() => {
+    //TODO don't mock here, just create the actual object and assert on basic behavior
     jest.mock('./adapters/UniqueIdProvider');
     jest.mock('./adapters/NativeCommandsSender');
     jest.mock('./adapters/NativeEventsReceiver');
 
     jest.mock('./containers/ContainerRegistry');
-    jest.mock('./commands/Commands');
+    jest.mock('./commands/AppCommands');
+    jest.mock('./commands/ContainerCommands');
 
     Navigation = require('./Navigation');
   });
@@ -21,16 +23,20 @@ describe('Navigation', () => {
   });
 
   it('setRoot delegates to Commands', async () => {
-    Navigation.commands.setRoot.mockReturnValue(Promise.resolve('result'));
+    Navigation.appCommands.setRoot.mockReturnValue(Promise.resolve('result'));
     const params = {};
     const result = await Navigation.setRoot(params);
     expect(result).toEqual('result');
-    expect(Navigation.commands.setRoot).toHaveBeenCalledTimes(1);
-    expect(Navigation.commands.setRoot).toHaveBeenCalledWith(params);
+    expect(Navigation.appCommands.setRoot).toHaveBeenCalledTimes(1);
+    expect(Navigation.appCommands.setRoot).toHaveBeenCalledWith(params);
   });
 
   it('events return the events registry', () => {
     expect(Navigation.events()).toBeDefined();
     expect(Navigation.events().onAppLaunched).toBeInstanceOf(Function);
   });
+
+  it('on containerId returns an object that performs commands on a container', () => {
+    expect(Navigation.on('myUniqueId').push).toBeInstanceOf(Function);
+  });
 });

src/adapters/NativeCommandsSender.js

@@ -9,4 +9,10 @@ export default class NativeCommandsSender {
     this.nativeCommandsModule.setRoot(layoutTree);
     return Promise.resolve(layoutTree);
   }
+
+  push(onContainerId, layout) {
+    this.nativeCommandsModule.push(onContainerId, layout);
+    return Promise.resolve(layout);
+  }
 }
+

src/adapters/NativeCommandsSender.mock.js

@@ -0,0 +1 @@
+export default jest.genMockFromModule('./NativeCommandsSender').default;

src/adapters/NativeCommandsSender.test.js

@@ -1,12 +1,15 @@
+import { NativeModules } from 'react-native';
+import NativeCommandsSender from './NativeCommandsSender';
+
 describe('NativeCommandsSender', () => {
   let uut, mockNativeModule;
 
   beforeEach(() => {
     mockNativeModule = {
-      setRoot: jest.fn()
+      setRoot: jest.fn(),
+      push: jest.fn()
     };
-    require('react-native').NativeModules.RNNBridgeModule = mockNativeModule;
-    const NativeCommandsSender = require('./NativeCommandsSender').default;
+    NativeModules.RNNBridgeModule = mockNativeModule;
     uut = new NativeCommandsSender();
   });
 
@@ -19,4 +22,11 @@ describe('NativeCommandsSender', () => {
     const result = await uut.setRoot({});
     expect(result).toBeDefined();
   });
+
+  it('push sends to native and resolves with promise', async () => {
+    const theNewContainer = {};
+    const result = await uut.push('theContainerId', theNewContainer);
+    expect(mockNativeModule.push).toHaveBeenCalledTimes(1);
+    expect(result).toBeDefined();
+  });
 });

src/adapters/NativeEventsReceiver.mock.js

@@ -0,0 +1 @@
+export default jest.genMockFromModule('./NativeEventsReceiver').default;

src/adapters/NativeEventsReceiver.test.js

@@ -1,10 +1,12 @@
+import { NativeModules } from 'react-native';
+import NativeEventsReceiver from './NativeEventsReceiver';
+
 describe('NativeEventsReceiver', () => {
   let uut;
   const eventEmitterMock = { addListener: jest.fn() };
 
   beforeEach(() => {
-    require('react-native').NativeModules.RNNEventEmitter = {};
-    const NativeEventsReceiver = require('./NativeEventsReceiver').default;
+    NativeModules.RNNEventEmitter = {};
     uut = new NativeEventsReceiver();
     uut.emitter = eventEmitterMock;
   });

src/adapters/UniqueIdProvider.mock.js

@@ -0,0 +1,6 @@
+export default class UniqueIdProvider {
+  generate(prefix) {
+    return `${prefix}+UNIQUE_ID`;
+  }
+}
+

src/adapters/UniqueIdProvider.test.js

@@ -1,19 +1,21 @@
+import UniqueIdProvider from './UniqueIdProvider';
+
 describe('UniqueIdProvider', () => {
   let uut;
 
   beforeEach(() => {
-    const UniqueIdProvider = require('./UniqueIdProvider').default;
     uut = new UniqueIdProvider();
   });
 
-  it('provides uniqueId', () => {
+  it('provides uniqueId with optional prefix', () => {
     expect(uut.generate()).toEqual('1');
     expect(uut.generate()).toEqual('2');
+    expect(uut.generate('prefix')).toEqual('prefix3');
+    expect(uut.generate('prefix')).toEqual('prefix4');
+    expect(uut.generate('other')).toEqual('other5');
   });
 
-  it('provides with prefix', () => {
-    expect(uut.generate('prefix')).toEqual('prefix1');
-    expect(uut.generate('prefix')).toEqual('prefix2');
-    expect(uut.generate('other')).toEqual('other3');
+  it('id is unique across instances', () => {
+    expect(uut.generate()).not.toEqual('1');
   });
 });

src/commands/AppCommands.js

@@ -0,0 +1,17 @@
+import _ from 'lodash';
+
+export default class AppCommands {
+  constructor(nativeCommandsSender, layoutTreeParser, layoutTreeCrawler) {
+    this.nativeCommandsSender = nativeCommandsSender;
+    this.layoutTreeParser = layoutTreeParser;
+    this.layoutTreeCrawler = layoutTreeCrawler;
+  }
+
+  setRoot(simpleApi) {
+    const input = _.cloneDeep(simpleApi);
+    const layout = this.layoutTreeParser.parseFromSimpleJSON(input);
+    this.layoutTreeCrawler.crawl(layout);
+    return this.nativeCommandsSender.setRoot(layout);
+  }
+}
+

src/commands/Commands.test.js → src/commands/AppCommands.test.js

@@ -1,21 +1,22 @@
 import * as SimpleLayouts from './SimpleLayouts';
+import LayoutTreeParser from './LayoutTreeParser';
+import LayoutTreeCrawler from './LayoutTreeCrawler';
+import Store from '../containers/Store';
+import UniqueIdProvider from '../adapters/UniqueIdProvider.mock';
+import NativeCommandsSender from '../adapters/NativeCommandsSender.mock';
 
-describe('Commands', () => {
+import AppCommands from './AppCommands';
+
+describe('AppCommands', () => {
   let uut;
   let mockCommandsSender;
   let store;
 
   beforeEach(() => {
-    const NativeCommandsSender = jest.genMockFromModule('../adapters/NativeCommandsSender').default;
     mockCommandsSender = new NativeCommandsSender();
-
-    const mockIdProvider = { generate: (prefix) => `${prefix}+UNIQUE_ID` };
-
-    const Store = require('../containers/Store').default;
     store = new Store();
 
-    const Commands = require('./Commands').default;
-    uut = new Commands(mockCommandsSender, mockIdProvider, store);
+    uut = new AppCommands(mockCommandsSender, new LayoutTreeParser(), new LayoutTreeCrawler(new UniqueIdProvider(), store));
   });
 
   describe('setRoot', () => {

src/commands/Commands.js

@@ -1,19 +0,0 @@
-import _ from 'lodash';
-import LayoutTreeParser from './LayoutTreeParser';
-import LayoutTreeCrawler from './LayoutTreeCrawler';
-
-export default class Commands {
-  constructor(nativeCommandsSender, uniqueIdProvider, store) {
-    this.nativeCommandsSender = nativeCommandsSender;
-    this.uniqueIdProvider = uniqueIdProvider;
-    this.layoutTreeParser = new LayoutTreeParser();
-    this.layoutTreeCrawler = new LayoutTreeCrawler(uniqueIdProvider, store);
-  }
-
-  setRoot(simpleApi) {
-    const input = _.cloneDeep(simpleApi);
-    const layout = this.layoutTreeParser.parseFromSimpleJSON(input);
-    this.layoutTreeCrawler.crawl(layout);
-    return this.nativeCommandsSender.setRoot(layout);
-  }
-}

src/commands/ContainerCommands.js

@@ -0,0 +1,17 @@
+import _ from 'lodash';
+
+export default class ContainerCommands {
+  constructor(containerId, nativeCommandsSender, layoutTreeParser, layoutTreeCrawler) {
+    this.containerId = containerId;
+    this.nativeCommandsSender = nativeCommandsSender;
+    this.layoutTreeParser = layoutTreeParser;
+    this.layoutTreeCrawler = layoutTreeCrawler;
+  }
+
+  push(containerData) {
+    const input = _.cloneDeep(containerData);
+    const layout = this.layoutTreeParser.createContainer(input);
+    this.layoutTreeCrawler.crawl(layout);
+    return this.nativeCommandsSender.push(this.containerId, layout);
+  }
+}

src/commands/ContainerCommands.test.js

@@ -0,0 +1,47 @@
+import NativeCommandsSender from '../adapters/NativeCommandsSender.mock';
+import UniqueIdProvider from '../adapters/UniqueIdProvider.mock';
+import Store from '../containers/Store';
+import LayoutTreeParser from './LayoutTreeParser';
+import LayoutTreeCrawler from './LayoutTreeCrawler';
+
+import ContainerCommands from './ContainerCommands';
+
+describe('ContainerCommands', () => {
+  let uut;
+  let mockCommandsSender;
+  const containerId = 'myUniqueId';
+
+  beforeEach(() => {
+    mockCommandsSender = new NativeCommandsSender();
+    uut = new ContainerCommands(containerId, mockCommandsSender, new LayoutTreeParser(), new LayoutTreeCrawler(new UniqueIdProvider(), new Store()));
+  });
+
+  it('holds containerId', () => {
+    expect(uut.containerId).toEqual('myUniqueId');
+  });
+
+  describe('push', () => {
+    it('deep clones input to avoid mutation errors', () => {
+      const obj = {};
+      uut.push({ inner: { foo: obj } });
+      expect(mockCommandsSender.push.mock.calls[0][1].data.inner.foo).not.toBe(obj);
+    });
+
+    it('resolves with the parsed layout', async () => {
+      mockCommandsSender.push.mockReturnValue(Promise.resolve('the resolved layout'));
+      const result = await uut.push({ name: 'com.example.MyScreen' });
+      expect(result).toEqual('the resolved layout');
+    });
+
+    it('parses into correct layout node and sends to native', () => {
+      uut.push({ name: 'com.example.MyScreen' });
+      expect(mockCommandsSender.push).toHaveBeenCalledTimes(1);
+      expect(mockCommandsSender.push).toHaveBeenCalledWith('myUniqueId', {
+        type: 'Container',
+        id: 'Container+UNIQUE_ID',
+        data: { name: 'com.example.MyScreen' },
+        children: []
+      });
+    });
+  });
+});

src/commands/LayoutTreeCrawler.test.js

@@ -1,16 +1,15 @@
 import LayoutTypes from './LayoutTypes';
+import LayoutTreeCrawler from './LayoutTreeCrawler';
+import Store from '../containers/Store';
+import UniqueIdProvider from '../adapters/UniqueIdProvider.mock';
 
 describe('LayoutTreeCrawler', () => {
   let uut;
   let store;
 
   beforeEach(() => {
-    const LayoutTreeCrawler = require('./LayoutTreeCrawler').default;
-    const uniqueIdProvider = { generate: (prefix) => `${prefix}+UNIQUE_ID` };
-    const Store = require('../containers/Store').default;
     store = new Store();
-
-    uut = new LayoutTreeCrawler(uniqueIdProvider, store);
+    uut = new LayoutTreeCrawler(new UniqueIdProvider(), store);
   });
 
   it('crawls a layout tree and adds unique id to each node', () => {

src/commands/LayoutTreeParser.js

@@ -12,28 +12,28 @@ export default class LayoutTreeParser {
     if (simpleJsonApi.tabs) {
       return this._createTabs(simpleJsonApi.tabs);
     }
-    return this._createContainerStackWithContainer(simpleJsonApi.container);
+    return this._createContainerStackWithContainerData(simpleJsonApi.container);
   }
 
-  _createTabs(tabs) {
+  createContainer(data) {
     return {
-      type: LayoutTypes.Tabs,
-      children: _.map(tabs, (t) => this._createContainerStackWithContainer(t.container))
+      type: LayoutTypes.Container,
+      data,
+      children: []
     };
   }
 
-  _createContainerStackWithContainer(container) {
+  _createTabs(tabs) {
     return {
-      type: LayoutTypes.ContainerStack,
-      children: [this._createContainer(container)]
+      type: LayoutTypes.Tabs,
+      children: _.map(tabs, (t) => this._createContainerStackWithContainerData(t.container))
     };
   }
 
-  _createContainer(container) {
+  _createContainerStackWithContainerData(containerData) {
     return {
-      type: LayoutTypes.Container,
-      data: container,
-      children: []
+      type: LayoutTypes.ContainerStack,
+      children: [this.createContainer(containerData)]
     };
   }
 
@@ -49,19 +49,19 @@ export default class LayoutTreeParser {
     if (layout.sideMenu.left) {
       children.push({
         type: LayoutTypes.SideMenuLeft,
-        children: [this._createContainer(layout.sideMenu.left.container)]
+        children: [this.createContainer(layout.sideMenu.left.container)]
       });
     }
     children.push({
       type: LayoutTypes.SideMenuCenter,
       children: [
-        layout.tabs ? this._createTabs(layout.tabs) : this._createContainerStackWithContainer(layout.container)
+        layout.tabs ? this._createTabs(layout.tabs) : this._createContainerStackWithContainerData(layout.container)
       ]
     });
     if (layout.sideMenu.right) {
       children.push({
         type: LayoutTypes.SideMenuRight,
-        children: [this._createContainer(layout.sideMenu.right.container)]
+        children: [this.createContainer(layout.sideMenu.right.container)]
       });
     }
     return children;

src/commands/LayoutTreeParser.test.js

@@ -1,287 +1,295 @@
 import * as SimpleLayouts from './SimpleLayouts';
+import LayoutTreeParser from './LayoutTreeParser';
 
 describe('LayoutTreeParser', () => {
   let uut;
 
   beforeEach(() => {
-    const LayoutTreeParser = require('./LayoutTreeParser').default;
     uut = new LayoutTreeParser();
   });
 
-  it('parses single screen', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.singleScreenApp))
-      .toEqual({
-        type: 'ContainerStack',
-        children: [
-          {
-            type: 'Container',
-            data: {
-              name: 'com.example.MyScreen'
-            },
-            children: []
-          }
-        ]
-      });
-  });
+  describe('parseFromSimpleJSON', () => {
+    it('parses single screen', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.singleScreenApp))
+        .toEqual({
+          type: 'ContainerStack',
+          children: [
+            {
+              type: 'Container',
+              data: {
+                name: 'com.example.MyScreen'
+              },
+              children: []
+            }
+          ]
+        });
+    });
 
-  it('parses single screen with props', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.singleScreenWithAditionalParams))
-      .toEqual({
-        type: 'ContainerStack',
-        children: [
-          {
-            type: 'Container',
-            children: [],
-            data: {
-              name: 'com.example.MyScreen',
-              passProps: SimpleLayouts.passProps,
-              style: {},
-              buttons: {}
+    it('parses single screen with props', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.singleScreenWithAditionalParams))
+        .toEqual({
+          type: 'ContainerStack',
+          children: [
+            {
+              type: 'Container',
+              children: [],
+              data: {
+                name: 'com.example.MyScreen',
+                passProps: SimpleLayouts.passProps,
+                style: {},
+                buttons: {}
+              }
             }
-          }
-        ]
-      });
-    const parsedPropsFn = uut.parseFromSimpleJSON(SimpleLayouts.singleScreenWithAditionalParams)
-      .children[0].data.passProps.fnProp;
-    expect(parsedPropsFn).toBe(SimpleLayouts.passProps.fnProp);
-    expect(parsedPropsFn()).toEqual('Hello from a function');
-  });
+          ]
+        });
+      const parsedPropsFn = uut.parseFromSimpleJSON(SimpleLayouts.singleScreenWithAditionalParams)
+        .children[0].data.passProps.fnProp;
+      expect(parsedPropsFn).toBe(SimpleLayouts.passProps.fnProp);
+      expect(parsedPropsFn()).toEqual('Hello from a function');
+    });
 
-  it('parses tab based', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.tabBasedApp))
-      .toEqual({
-        type: 'Tabs',
-        children: [
-          {
-            type: 'ContainerStack',
-            children: [
-              {
-                type: 'Container',
-                children: [],
-                data: {
-                  name: 'com.example.ATab'
+    it('parses tab based', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.tabBasedApp))
+        .toEqual({
+          type: 'Tabs',
+          children: [
+            {
+              type: 'ContainerStack',
+              children: [
+                {
+                  type: 'Container',
+                  children: [],
+                  data: {
+                    name: 'com.example.ATab'
+                  }
                 }
-              }
-            ]
-          },
-          {
-            type: 'ContainerStack',
-            children: [
-              {
-                type: 'Container',
-                children: [],
-                data: {
-                  name: 'com.example.SecondTab'
+              ]
+            },
+            {
+              type: 'ContainerStack',
+              children: [
+                {
+                  type: 'Container',
+                  children: [],
+                  data: {
+                    name: 'com.example.SecondTab'
+                  }
                 }
-              }
-            ]
-          },
-          {
-            type: 'ContainerStack',
-            children: [
-              {
-                type: 'Container',
-                children: [],
-                data: {
-                  name: 'com.example.ATab'
+              ]
+            },
+            {
+              type: 'ContainerStack',
+              children: [
+                {
+                  type: 'Container',
+                  children: [],
+                  data: {
+                    name: 'com.example.ATab'
+                  }
                 }
-              }
-            ]
-          }
-        ]
-      });
-  });
+              ]
+            }
+          ]
+        });
+    });
 
-  it('parses side menus', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithSideMenu))
-      .toEqual({
-        type: 'SideMenuRoot',
-        children: [
-          {
-            type: 'SideMenuLeft',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.SideMenu'
-                },
-                children: []
-              }
-            ]
-          },
-          {
-            type: 'SideMenuCenter',
-            children: [
-              {
-                type: 'ContainerStack',
-                children: [
-                  {
-                    type: 'Container',
-                    data: {
-                      name: 'com.example.MyScreen'
-                    },
-                    children: []
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      });
-  });
+    it('parses side menus', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithSideMenu))
+        .toEqual({
+          type: 'SideMenuRoot',
+          children: [
+            {
+              type: 'SideMenuLeft',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.SideMenu'
+                  },
+                  children: []
+                }
+              ]
+            },
+            {
+              type: 'SideMenuCenter',
+              children: [
+                {
+                  type: 'ContainerStack',
+                  children: [
+                    {
+                      type: 'Container',
+                      data: {
+                        name: 'com.example.MyScreen'
+                      },
+                      children: []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        });
+    });
 
-  it('parses side menu right', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithRightSideMenu))
-      .toEqual({
-        type: 'SideMenuRoot',
-        children: [
-          {
-            type: 'SideMenuCenter',
-            children: [
-              {
-                type: 'ContainerStack',
-                children: [
-                  {
-                    type: 'Container',
-                    data: {
-                      name: 'com.example.MyScreen'
-                    },
-                    children: []
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            type: 'SideMenuRight',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.SideMenu'
-                },
-                children: []
-              }
-            ]
-          }
-        ]
-      });
-  });
+    it('parses side menu right', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithRightSideMenu))
+        .toEqual({
+          type: 'SideMenuRoot',
+          children: [
+            {
+              type: 'SideMenuCenter',
+              children: [
+                {
+                  type: 'ContainerStack',
+                  children: [
+                    {
+                      type: 'Container',
+                      data: {
+                        name: 'com.example.MyScreen'
+                      },
+                      children: []
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: 'SideMenuRight',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.SideMenu'
+                  },
+                  children: []
+                }
+              ]
+            }
+          ]
+        });
+    });
 
-  it('parses both side menus', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithBothMenus))
-      .toEqual({
-        type: 'SideMenuRoot',
-        children: [
-          {
-            type: 'SideMenuLeft',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.Menu1'
-                },
-                children: []
-              }
-            ]
-          },
-          {
-            type: 'SideMenuCenter',
-            children: [
-              {
-                type: 'ContainerStack',
-                children: [
-                  {
-                    type: 'Container',
-                    data: {
-                      name: 'com.example.MyScreen'
+    it('parses both side menus', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.singleWithBothMenus))
+        .toEqual({
+          type: 'SideMenuRoot',
+          children: [
+            {
+              type: 'SideMenuLeft',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.Menu1'
+                  },
+                  children: []
+                }
+              ]
+            },
+            {
+              type: 'SideMenuCenter',
+              children: [
+                {
+                  type: 'ContainerStack',
+                  children: [
+                    {
+                      type: 'Container',
+                      data: {
+                        name: 'com.example.MyScreen'
+                      },
+                      children: []
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: 'SideMenuRight',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.Menu2'
+                  },
+                  children: []
+                }
+              ]
+            }
+          ]
+        });
+    });
+
+    it('parses tabs with side menus', () => {
+      expect(uut.parseFromSimpleJSON(SimpleLayouts.tabBasedWithBothSideMenus))
+        .toEqual({
+          type: 'SideMenuRoot',
+          children: [
+            {
+              type: 'SideMenuLeft',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.Menu1'
+                  },
+                  children: []
+                }
+              ]
+            },
+            {
+              type: 'SideMenuCenter',
+              children: [
+                {
+                  type: 'Tabs',
+                  children: [
+                    {
+                      type: 'ContainerStack',
+                      children: [
+                        {
+                          type: 'Container',
+                          data: {
+                            name: 'com.example.FirstTab'
+                          },
+                          children: []
+                        }
+                      ]
                     },
-                    children: []
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            type: 'SideMenuRight',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.Menu2'
-                },
-                children: []
-              }
-            ]
-          }
-        ]
-      });
+                    {
+                      type: 'ContainerStack',
+                      children: [
+                        {
+                          type: 'Container',
+                          data: {
+                            name: 'com.example.SecondTab'
+                          },
+                          children: []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: 'SideMenuRight',
+              children: [
+                {
+                  type: 'Container',
+                  data: {
+                    name: 'com.example.Menu2'
+                  },
+                  children: []
+                }
+              ]
+            }
+          ]
+        });
+    });
   });
 
-  it('parses tabs with side menus', () => {
-    expect(uut.parseFromSimpleJSON(SimpleLayouts.tabBasedWithBothSideMenus))
-      .toEqual({
-        type: 'SideMenuRoot',
-        children: [
-          {
-            type: 'SideMenuLeft',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.Menu1'
-                },
-                children: []
-              }
-            ]
-          },
-          {
-            type: 'SideMenuCenter',
-            children: [
-              {
-                type: 'Tabs',
-                children: [
-                  {
-                    type: 'ContainerStack',
-                    children: [
-                      {
-                        type: 'Container',
-                        data: {
-                          name: 'com.example.FirstTab'
-                        },
-                        children: []
-                      }
-                    ]
-                  },
-                  {
-                    type: 'ContainerStack',
-                    children: [
-                      {
-                        type: 'Container',
-                        data: {
-                          name: 'com.example.SecondTab'
-                        },
-                        children: []
-                      }
-                    ]
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            type: 'SideMenuRight',
-            children: [
-              {
-                type: 'Container',
-                data: {
-                  name: 'com.example.Menu2'
-                },
-                children: []
-              }
-            ]
-          }
-        ]
-      });
+  describe('createContainer', () => {
+    it('creates container object with passed data', () => {
+      expect(uut.createContainer({ foo: 'bar' })).toEqual({ type: 'Container', data: { foo: 'bar' }, children: [] });
+    });
   });
 });

src/containers/ContainerRegistry.test.js

@@ -2,6 +2,9 @@ import React, { Component } from 'react';
 import { AppRegistry, Text } from 'react-native';
 import renderer from 'react-test-renderer';
 
+import ContainerRegistry from './ContainerRegistry';
+import Store from './Store';
+
 describe('ContainerRegistry', () => {
   let uut;
 
@@ -13,8 +16,6 @@ describe('ContainerRegistry', () => {
 
   beforeEach(() => {
     AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
-    const ContainerRegistry = require('./ContainerRegistry').default;
-    const Store = require('./Store').default;
     uut = new ContainerRegistry(new Store());
   });
 

src/containers/ContainerWrapper.test.js

@@ -2,8 +2,10 @@ import React, { Component } from 'react';
 import { AppRegistry, Text } from 'react-native';
 import renderer from 'react-test-renderer';
 
+import ContainerWrapper from './ContainerWrapper';
+import Store from './Store';
+
 describe('ContainerWrapper', () => {
-  let ContainerWrapper;
   let myContainerRef;
   let testParentRef;
   let store;
@@ -37,8 +39,6 @@ describe('ContainerWrapper', () => {
   }
 
   beforeEach(() => {
-    ContainerWrapper = require('./ContainerWrapper').default;
-    const Store = require('./Store').default;
     store = new Store();
   });
 

src/containers/Store.test.js

@@ -1,8 +1,9 @@
+import Store from './Store';
+
 describe('Store', () => {
   let uut;
 
   beforeEach(() => {
-    const Store = require('./Store').default;
     uut = new Store();
   });