refactoring and fixing dependencies

ios/RNNBridgeModule.m

 
 @implementation RNNBridgeModule
 
-RCT_EXPORT_MODULE(NativeNavigation);
+RCT_EXPORT_MODULE();
 
 - (dispatch_queue_t)methodQueue
 {

src/Navigation.js

 import * as ContainerRegistry from './containers/ContainerRegistry';
-import * as Commands from './commands/Commands';
 
+import nativeCommandsSender from './adapters/NativeCommandsSender';
 import NativeEventsReceiver from './adapters/NativeEventsReceiver';
+import UniqueIdProvider from './adapters/UniqueIdProvider';
+import Commands from './commands/Commands';
 
 class Navigation {
   constructor() {
     this.nativeEventsReceiver = new NativeEventsReceiver();
+    this.uniqueIdProvider = new UniqueIdProvider();
+    this.commands = new Commands(nativeCommandsSender, this.uniqueIdProvider);
   }
 
   registerContainer(containerName, getContainerFunc) {
   }
 
   startApp(params) {
-    Commands.startApp(params);
+    this.commands.startApp(params);
   }
 
   onAppLaunched(fn) {
     this.nativeEventsReceiver.onAppLaunched(fn);
   }
-
 }
 
 const singleton = new Navigation();
-
 module.exports = singleton;
-

src/Navigation.test.js

 describe('Navigation', () => {
   let Navigation;
-  let ContainerRegistry, Commands;
-  let mockNativeEventsReceiver;
+  let ContainerRegistry;
 
   beforeEach(() => {
     jest.mock('./containers/ContainerRegistry');
-    jest.mock('./commands/Commands');
     ContainerRegistry = require('./containers/ContainerRegistry');
-    Commands = require('./commands/Commands');
 
-    mockNativeEventsReceiver = {
-      onAppLaunched: jest.fn()
-    };
+    jest.mock('./adapters/UniqueIdProvider');
+    jest.mock('./adapters/NativeCommandsSender');
+    jest.mock('./adapters/NativeEventsReceiver');
 
-    jest.mock('./adapters/NativeEventsReceiver', () => () => mockNativeEventsReceiver);
+    jest.mock('./commands/Commands');
 
     Navigation = require('./Navigation');
   });
   it('startApp delegates to Commands', () => {
     const params = {};
     Navigation.startApp(params);
-    expect(Commands.startApp).toHaveBeenCalledTimes(1);
-    expect(Commands.startApp).toHaveBeenCalledWith(params);
+    expect(Navigation.commands.startApp).toHaveBeenCalledTimes(1);
+    expect(Navigation.commands.startApp).toHaveBeenCalledWith(params);
   });
 
   it('onAppLaunched delegates to NativeEventsReceiver', () => {
-    Navigation.onAppLaunched(jest.fn());
-    expect(mockNativeEventsReceiver.onAppLaunched).toHaveBeenCalledTimes(1);
+    const fn = jest.fn();
+    Navigation.onAppLaunched(fn);
+    expect(Navigation.nativeEventsReceiver.onAppLaunched).toHaveBeenCalledTimes(1);
+    expect(Navigation.nativeEventsReceiver.onAppLaunched).toHaveBeenCalledWith(fn);
   });
 });

src/adapters/NativeCommandsSender.js

+import {NativeModules} from 'react-native';
+
+const singleton = NativeModules.RNNBridgeModule;
+export default singleton;

src/adapters/UniqueIdProvider.js

 import _ from 'lodash';
 
-export function uniqueId(prefix) {
-  return _.uniqueId(prefix);
+export default class UniqueIdProvider {
+  generate(prefix) {
+    return _.uniqueId(prefix);
+  }
 }

src/adapters/UniqueIdProvider.test.js

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

src/adapters/__mocks__/UniqueIdProvider.js

-export function uniqueId(prefix) {
-  return `${prefix}UNIQUE`;
-}

src/commands/Commands.js

-import {NativeModules} from 'react-native';
-const {NativeNavigation} = NativeModules;
-import * as LayoutBuilder from './LayoutBuilder';
+import LayoutTreeParser from './LayoutTreeParser';
 
-export function startApp(params) {
-  NativeNavigation.startApp(LayoutBuilder.parse(params));
+export default class Commands {
+  constructor(nativeCommandsSender, uniqueIdProvider) {
+    this.nativeCommandsSender = nativeCommandsSender;
+    this.layoutTreeParser = new LayoutTreeParser(uniqueIdProvider);
+  }
+
+  startApp(params) {
+    this.nativeCommandsSender.startApp(this.layoutTreeParser.parse(params));
+  }
 }

src/commands/Commands.test.js

 describe('Commands', () => {
   let uut;
-  let mockNativeNavigation;
+  const nativeCommandsSender = {
+    startApp: jest.fn()
+  };
+  const uniqueIdProvider = {
+    generate: (prefix) => `${prefix}UNIQUE`
+  };
 
   beforeEach(() => {
-    mockNativeNavigation = {
-      startApp: jest.fn()
-    };
-    require('react-native').NativeModules.NativeNavigation = mockNativeNavigation;
-    uut = require('./Commands');
+    const Commands = require('./Commands').default;
+    uut = new Commands(nativeCommandsSender, uniqueIdProvider);
   });
 
   describe('startApp', () => {
-    it('sends startApp to native', () => {
+    it('sends startApp to native after parsing into layoutTree', () => {
       uut.startApp({
         container: {
           name: 'com.example.MyScreen'
         }
       });
-      expect(mockNativeNavigation.startApp).toHaveBeenCalledTimes(1);
+      expect(nativeCommandsSender.startApp).toHaveBeenCalledTimes(1);
+      //TODO
     });
   });
 });

src/commands/LayoutBuilder.js

-import _ from 'lodash';
-import {uniqueId} from '../adapters/UniqueIdProvider';
-
-export function parse(params) {
-  const layout = _.merge({}, params);
-  if (layout.container) {
-    layout.container.id = uniqueId(`container`);
-  }
-  if (layout.sideMenu) {
-    if (layout.sideMenu.left) {
-      layout.sideMenu.left.id = uniqueId(`container`);
-    }
-    if (layout.sideMenu.right) {
-      layout.sideMenu.right.id = uniqueId(`container`);
-    }
-  }
-  if (layout.tabs) {
-    _.forEach(layout.tabs, (t) => t.container.id = uniqueId(`container`));
-  }
-  return layout;
-}

src/commands/LayoutTreeParser.js

+import _ from 'lodash';
+
+export default class LayoutTreeParser {
+  constructor(uniqueIdProvider) {
+    this.uniqueIdProvider = uniqueIdProvider;
+  }
+
+  parse(params) {
+    const layout = _.merge({}, params);
+    if (layout.container) {
+      layout.container.id = this.uniqueIdProvider.generate(`container`);
+    }
+    if (layout.sideMenu) {
+      if (layout.sideMenu.left) {
+        layout.sideMenu.left.id = this.uniqueIdProvider.generate(`container`);
+      }
+      if (layout.sideMenu.right) {
+        layout.sideMenu.right.id = this.uniqueIdProvider.generate(`container`);
+      }
+    }
+    if (layout.tabs) {
+      _.forEach(layout.tabs, (t) => t.container.id = this.uniqueIdProvider.generate(`container`));
+    }
+    return layout;
+  }
+}

src/commands/LayoutBuilder.test.js → src/commands/LayoutTreeParser.test.js

-describe('LayoutBuilder', () => {
+xdescribe('LayoutTreeParser', () => {
   let LayoutBuilder;
 
   beforeEach(() => {
     jest.mock('../adapters/UniqueIdProvider');
-    LayoutBuilder = require('./LayoutBuilder');
+    LayoutBuilder = require('./LayoutTreeParser');
   });
 
   describe('parse', () => {

src/containers/ContainerRegistry.js

 import React, {Component} from 'react';
 import {AppRegistry} from 'react-native';
+
 import * as Store from './Store';
 
 export function registerContainer(containerName, getContainerFunc) {

src/index.test.js

+jest.mock('./Navigation', () => ({startApp: () => 'import'}));
 import Navigation from './index';
 
 describe('index', () => {
   let uut;
 
   beforeEach(() => {
+    jest.mock('./Navigation', () => ({startApp: () => 'require'}));
     uut = require('./index');
   });
 
   it('exposes Navigation', () => {
-    expect(uut.startApp).toBeInstanceOf(Function);
-    expect(Navigation.startApp).toBeInstanceOf(Function);
+    expect(uut.startApp()).toEqual('require');
+    expect(Navigation.startApp()).toEqual('import');
   });
 });