starting work on commands

src2/Navigation.js

-export function registerContainer(params) {
-  //
+import * as ContainerRegistry from './containers/ContainerRegistry';
+
+export function registerContainer(containerKey, getContainerFunc) {
+  ContainerRegistry.registerContainer(containerKey, getContainerFunc);
 }
 
 export function startApp(params) {

src2/Navigation.test.js

 
 describe('Navigation', () => {
   let Navigation;
+  let Commands;
+  let ContainerRegistry;
 
   beforeEach(() => {
+    jest.mock('./containers/ContainerRegistry');
     Navigation = require('./Navigation');
+    Commands = require('./commands/Commands');
+    ContainerRegistry = require('./containers/ContainerRegistry');
   });
 
   it('exposes static commands', () => {
       Navigation.dismissInAppNotification
     ], (f) => expect(f).toBeInstanceOf(Function));
   });
+
+  it('delegates register container to container registry', () => {
+    expect(ContainerRegistry.registerContainer).not.toHaveBeenCalled();
+    const fn = jest.fn();
+    Navigation.registerContainer('key', fn);
+    expect(ContainerRegistry.registerContainer).toHaveBeenCalledTimes(1);
+    expect(ContainerRegistry.registerContainer).toHaveBeenCalledWith('key', fn);
+  });
 });

src2/commands/Commands.js

+import _ from 'lodash';
+
+export function startApp(params) {
+  validateParams(params);
+}
+
+function validateParams(params) {
+  const msg = `invalid params passed to startApp: ${params}`;
+  if (!params) {
+    throw new Error(msg);
+  }
+  if (params.screenKey) {
+    return true;
+  }
+  if (params.tabs && params.tabs.length > 0 && _.every(params.tabs, (t) => t.screenKey)) {
+    return true;
+  }
+  throw new Error(msg);
+}

src2/commands/Commands.test.js

+describe('Commands', () => {
+  let uut;
+
+  beforeEach(() => {
+    uut = require('./Commands');
+  });
+
+  describe('startApp', () => {
+    it('receives params object', () => {
+      uut.startApp({
+        screenKey: {
+          screen: 'example.MyScreen'
+        },
+        drawer: {
+          left: {
+            screen: 'example.SideMenu'
+          }
+        }
+      });
+    });
+
+    it('expects to get screenKey, or tabs with screenKeys', () => {
+      expect(() => uut.startApp({screenKey: 'example.MyScreen'})).not.toThrow();
+      expect(() => uut.startApp({tabs: [{screenKey: 'example.Tab1'}]})).not.toThrow();
+      expect(() => uut.startApp()).toThrow();
+      expect(() => uut.startApp({})).toThrow();
+      expect(() => uut.startApp({tabs: []})).toThrow();
+      expect(() => uut.startApp({tabs: [{}]})).toThrow();
+      expect(() => uut.startApp({tabs: [{screenKey: 'example.Tab1'}, {}]})).toThrow();
+    });
+  });
+});

src2/containers/ContainerRegistry.js

   AppRegistry.registerComponent(containerKey, () => NavigationContainer);
 }
 
-export function getRegisteredContainer(containerKey) {
-  return ContainerStore.getContainerClass(containerKey);
-}
-
 function wrapContainer(containerKey, OriginalContainer) {
   return class extends Component {
     constructor(props) {

src2/containers/ContainerRegistry.test.js

   let uut;
   let myContainerRef;
   let testParentRef;
+  let containerStore;
 
   class MyContainer extends Component {
     constructor(props) {
 
   beforeEach(() => {
     uut = require('./ContainerRegistry');
+    containerStore = require('./ContainerStore');
   });
 
   afterEach(() => {
   });
 
   describe('registerContainer', () => {
-    it('registers container component by containerKey into AppRegistry', () => {
+    beforeEach(() => {
       AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
+    });
+
+    it('registers container component by containerKey into AppRegistry', () => {
       expect(AppRegistry.registerComponent).not.toHaveBeenCalled();
       uut.registerContainer('example.MyContainer.key', () => MyContainer);
       expect(AppRegistry.registerComponent).toHaveBeenCalledTimes(1);
     });
 
     it('resulting in a normal component', () => {
-      AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
       uut.registerContainer('example.MyContainer.key', () => MyContainer);
       const Container = AppRegistry.registerComponent.mock.calls[0][1]();
       const tree = renderer.create(<Container screenId="123"/>);
     });
   });
 
-  describe('wrapping NavigationContainer', () => {
+  describe('NavigationContainer wrapping', () => {
     const containerKey = 'example.MyContainer';
 
     beforeEach(() => {
       uut.registerContainer(containerKey, () => MyContainer);
     });
 
-    it('asserts has screenId as prop', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+    it('must have screenId as prop', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       expect(() => {
         renderer.create(<NavigationContainer/>);
       }).toThrow(new Error('Screen example.MyContainer does not have a screenId!'));
     });
 
     it('wraps the container and saves to store', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      expect(NavigationContainer).not.toBeInstanceOf(MyContainer);
       const tree = renderer.create(<NavigationContainer screenId={'screen1'}/>);
       expect(tree.toJSON().children).toEqual(['Hello, World!']);
       expect(myContainerRef).toBeInstanceOf(MyContainer);
     });
 
     it('injects props from wrapper into original container', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       renderer.create(<NavigationContainer screenId={'screen1'} myProp={'yo'}/>);
       expect(myContainerRef.props.myProp).toEqual('yo');
     });
 
     it('updates props from wrapper into original container', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       renderer.create(<TestParent ChildClass={NavigationContainer}/>);
       expect(myContainerRef.props.foo).toEqual(undefined);
       testParentRef.setState({propsFromState: {foo: 'yo'}});
 
     it('pulls props from the PropsStore and injects them into the inner container', () => {
       require('./PropsStore').setPropsForScreenId('screen123', {numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       renderer.create(<NavigationContainer screenId={'screen123'}/>);
       expect(myContainerRef.props).toEqual({screenId: 'screen123', numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
     });
 
     it('updates props from PropsStore into inner container', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       renderer.create(<TestParent ChildClass={NavigationContainer}/>);
       require('./PropsStore').setPropsForScreenId('screen1', {myProp: 'hello'});
       expect(myContainerRef.props.foo).toEqual(undefined);
     });
 
     it('protects screenId from change', () => {
-      const NavigationContainer = uut.getRegisteredContainer(containerKey);
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
       renderer.create(<TestParent ChildClass={NavigationContainer}/>);
       expect(myContainerRef.props.screenId).toEqual('screen1');
       testParentRef.setState({propsFromState: {screenId: 'ERROR'}});