parsing commands

src/Navigation.js

 import * as ContainerRegistry from './containers/ContainerRegistry';
-import {NativeModules} from 'react-native';
-const {NativeNavigation} = NativeModules;
+import * as Commands from './commands/Commands';
 
 export function registerContainer(containerKey, getContainerFunc) {
   ContainerRegistry.registerContainer(containerKey, getContainerFunc);
 }
 
 export function startApp(params) {
-  NativeNavigation.startApp(params);
+  Commands.startApp(params);
 }
 
 export function push(params) {

src/Navigation.test.js

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

src/commands/Commands.js

 import _ from 'lodash';
+import {NativeModules} from 'react-native';
+const {NativeNavigation} = NativeModules;
+import {uniqueId} from '../providers/UniqueIdProvider';
 
 export function startApp(params) {
-  validateParams(params);
+  NativeNavigation.startApp();
 }
+//
+//function parseParams(params) {
+//  const msg = `invalid params passed to startApp: ${params}`;
+//  if (!params) {
+//    throw new Error(msg);
+//  }
+//
+//  if (params.tabs) {
+//    return parseTabs(params);
+//  }
+//
+//  if (params.container) {
+//    return parseContainer(params);
+//  }
+//
+//  throw new Error(msg);
+//}
+//
+//function parseTabs(params) {
+////&& params.tabs.length > 0 && _.every(params.tabs, (t) => t.containerKey)
+//}
+//
+//function parseContainer(params) {
+//
+//}
 
-function validateParams(params) {
-  const msg = `invalid params passed to startApp: ${params}`;
-  if (!params) {
-    throw new Error(msg);
-  }
-  if (params.containerKey) {
-    return true;
-  }
-  if (params.tabs && params.tabs.length > 0 && _.every(params.tabs, (t) => t.containerKey)) {
-    return true;
-  }
-  throw new Error(msg);
+export function parse(params) {
+  return {
+    containerStack: {
+      id: uniqueId(`containerStack`),
+      stack: [
+        {
+          container: {
+            id: uniqueId(`container`),
+            key: params.container.key
+          }
+        }
+      ]
+    }
+  };
 }

src/commands/Commands.test.js

 describe('Commands', () => {
   let uut;
+  let mockNativeNavigation;
+  let mockUniqueIdProvider;
 
   beforeEach(() => {
+    mockNativeNavigation = {
+      startApp: jest.fn()
+    };
+    require('react-native').NativeModules.NativeNavigation = mockNativeNavigation;
+    jest.mock('../providers/UniqueIdProvider');
+    mockUniqueIdProvider = require('../providers/UniqueIdProvider');
     uut = require('./Commands');
   });
 
   describe('startApp', () => {
-    it('receives params object', () => {
+    it('sends startApp to native', () => {
       uut.startApp({
-        containerKey: {
-          root: 'example.MyContainer'
-        },
-        drawer: {
-          left: {
-            root: 'example.SideMenu'
-          }
+        container: {
+          key: 'example.MyContainer'
         }
       });
+      expect(mockNativeNavigation.startApp).toHaveBeenCalledTimes(1);
     });
 
-    it('expects to get containerKey, or tabs with containerKeys', () => {
-      expect(() => uut.startApp({containerKey: 'example.MyContainer'})).not.toThrow();
-      expect(() => uut.startApp({tabs: [{containerKey: '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: [{containerKey: 'example.Tab1'}, {}]})).toThrow();
+    it('parses the params and construct single screen hirarchy', () => {
+      mockUniqueIdProvider.uniqueId = jest.fn((prefix) => `${prefix}123`);
+
+      expect(uut.parse(
+        {
+          container: {
+            key: 'com.example.MyScreen'
+          }
+        })).toEqual(
+        {
+          containerStack: {
+            id: 'containerStack123',
+            stack: [
+              {
+                container: {
+                  key: 'com.example.MyScreen',
+                  id: 'container123'
+                }
+              }
+            ]
+          }
+        });
     });
+    //it('receives params object', () => {
+    //  uut.startApp({
+    //    container: {
+    //      key: 'example.MyContainer'
+    //    },
+    //    drawer: {
+    //      left: {
+    //        key: 'example.SideMenu'
+    //      }
+    //    }
+    //  });
+    //});
+    //it('expects to get containerKey, or tabs with containerKeys', () => {
+    //  expect(() => uut.startApp({containerKey: 'example.MyContainer'})).not.toThrow();
+    //  expect(() => uut.startApp({tabs: [{containerKey: '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: [{containerKey: 'example.Tab1'}, {}]})).toThrow();
+    //});
   });
 });

src/providers/UniqueIdProvider.js

+import _ from 'lodash';
+
+export function uniqueId(prefix) {
+  return _.uniqueId(prefix);
+}

src/providers/UniqueIdProvider.test.js

+describe('UniqueIdProvider', () => {
+  let uut;
+
+  beforeEach(() => {
+    uut = require('./UniqueIdProvider');
+  });
+
+  it('provides uniqueId', () => {
+    expect(uut.uniqueId()).toEqual('1');
+    expect(uut.uniqueId()).toEqual('2');
+  });
+
+  it('provides with prefix', () => {
+    expect(uut.uniqueId('prefix')).toEqual('prefix1');
+    expect(uut.uniqueId('prefix')).toEqual('prefix2');
+    expect(uut.uniqueId('other')).toEqual('other3');
+  });
+});