Android: ContainerStack support in Layout-Factory

android/app/build.gradle

     // required for robolectric
     testCompile 'org.khronos:opengl-api:gl1.1-android-2.1_r1'
 
-//    testCompile 'org.mockito:mockito-core:2.+'
+    testCompile 'org.mockito:mockito-core:2.+'
 }

android/app/src/main/AndroidManifest.xml

 
     <application>
         <activity android:name=".controllers.NavigationActivity"/>
-        <!--<activity-->
-            <!--android:name=".controllers.PortraitNavigationActivity"-->
-            <!--android:screenOrientation="portrait" />-->
-        <!--<activity-->
-            <!--android:name=".controllers.LandscapeNavigationActivity"-->
-            <!--android:screenOrientation="landscape" />-->
-        <!--<activity-->
-            <!--android:name="com.facebook.react.devsupport.DevSettingsActivity"-->
-            <!--android:exported="false" />-->
+
+        <!--<activity
+            android:name="com.facebook.react.devsupport.DevSettingsActivity"
+            android:exported="false" />-->
     </application>
 </manifest>

android/app/src/main/java/com/reactnativenavigation/layout/LayoutFactory.java

         View createRootView(String id, String name);
     }
 
+    public static class LayoutNode {
+        public String id;
+        public String type;
+        public Map<String, Object> data;
+        public List<LayoutNode> children;
+
+        public LayoutNode() {
+        }
+
+        public LayoutNode(String id, String type, Map<String, Object> data) {
+            this.id = id;
+            this.type = type;
+            this.data = data;
+        }
+    }
+
     private Activity activity;
     private RootViewCreator rootViewCreator;
 
         this.rootViewCreator = rootViewCreator;
     }
 
-    public View create(Map<String, Object> node) {
-        String id = (String) node.get("id");
-        String type = (String) node.get("type");
-
-        switch (type) {
+    public View create(LayoutNode node) {
+        switch (node.type) {
             case "Container":
-                String name = (String) ((Map<String, Object>)node.get("data")).get("name");
-                return new Container(activity, rootViewCreator, id, name);
+                String name = (String) node.data.get("name");
+                return new Container(activity, rootViewCreator, node.id, name);
 
             case "ContainerStack":
                 ContainerStack containerStack = new ContainerStack(activity);
-                List<Map<String, Object>> children = (List<Map<String, Object>>) node.get("children");
-                Map<String, Object> inner = children.get(0);
-                containerStack.addView(create(inner));
+                List<LayoutNode> children = node.children;
+                addChildrenNodes(containerStack, children);
                 return containerStack;
-
         }
 
         return null;
 //        return rootViewCreator.createRootView(id, name);
     }
+
+    private void addChildrenNodes(ContainerStack containerStack, List<LayoutNode> children) {
+        for (LayoutNode child : children) {
+            containerStack.addView(create(child));
+        }
+    }
 }

android/app/src/test/java/com/reactnativenavigation/LayoutFactoryTest.java

 import com.reactnativenavigation.layout.Container;
 import com.reactnativenavigation.layout.ContainerStack;
 import com.reactnativenavigation.layout.LayoutFactory;
+import com.reactnativenavigation.layout.LayoutFactory.LayoutNode;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.robolectric.RobolectricTestRunner;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 
 @RunWith(RobolectricTestRunner.class)
 public class LayoutFactoryTest {
+
+    private final static String VIEW_ID = "myUniqueId";
+    private final static String VIEW_NAME = "myName";
+
+    private final static String OTHER_VIEW_ID = "anotherUniqueId";
+    private final static String OTHER_VIEW_NAME = "anotherName";
+
+    private View mockView;
+    private LayoutFactory.RootViewCreator rootViewCreator;
+
     @Before
     public void setUp() {
-
+        mockView = new View(Robolectric.setupActivity(Activity.class));
+        rootViewCreator = mock(LayoutFactory.RootViewCreator.class);
     }
 
     @Test
     public void returnsContainerThatHoldsTheRootView() {
-        final AtomicReference<String> idRef = new AtomicReference<>();
-        final AtomicReference<String> nameRef = new AtomicReference<>();
-        final AtomicReference<View> viewRef = new AtomicReference<>();
-
-        LayoutFactory.RootViewCreator rootViewCreator = new LayoutFactory.RootViewCreator() {
-            @Override
-            public View createRootView(String id, String name) {
-                idRef.set(id);
-                nameRef.set(name);
-                viewRef.set(new View(Robolectric.setupActivity(Activity.class)));
-                return viewRef.get();
-            }
-        };
-
-        Map<String, Object> node = new HashMap() {{
-            Map<String, Object> data = new HashMap<>();
-            data.put("name", "MyName");
-            put("id", "myUniqueId");
-            put("data", data);
-            put("type", "Container");
-        }};
-
-        ViewGroup result =
-                (ViewGroup) new LayoutFactory(Robolectric.buildActivity(Activity.class).get(), rootViewCreator).create(node);
+        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
+        final LayoutNode node = createContainerNode();
+
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(node);
+
         assertThat(result).isInstanceOf(Container.class);
-        assertThat(result.getChildCount()).isEqualTo(1);
-        assertThat(result.getChildAt(0)).isEqualTo(viewRef.get());
+        assertViewChildren(result, mockView);
     }
 
-
     @Test
     public void returnsContainerStack() {
-        final AtomicReference<String> idRef = new AtomicReference<>();
-        final AtomicReference<String> nameRef = new AtomicReference<>();
-        final AtomicReference<View> viewRef = new AtomicReference<>();
-
-        LayoutFactory.RootViewCreator rootViewCreator = new LayoutFactory.RootViewCreator() {
-            @Override
-            public View createRootView(String id, String name) {
-                idRef.set(id);
-                nameRef.set(name);
-                viewRef.set(new View(Robolectric.setupActivity(Activity.class)));
-                return viewRef.get();
-            }
-        };
-
-        Map<String, Object> node = new HashMap() {{
-            Map<String, Object> data = new HashMap<>();
-            data.put("name", "MyName");
-            put("id", "myUniqueId");
-            put("data", data);
-            put("type", "Container");
-        }};
-
-        HashMap<String, Object> outerNode = new HashMap<>();
-        outerNode.put("type", "ContainerStack");
-        List<Map<String, Object>> children = new ArrayList<>();
-        children.add(node);
-        outerNode.put("children", children);
-
-        ViewGroup result =
-                (ViewGroup) new LayoutFactory(Robolectric.buildActivity(Activity.class).get(), rootViewCreator).create(outerNode);
+        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
+        final LayoutNode node = createContainerNode();
+        final LayoutNode outerNode = getContainerStackNode(node);
+
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(outerNode);
+
+        assertThat(result).isInstanceOf(ContainerStack.class);
+        ViewGroup container = (ViewGroup) assertViewChildrenCount(result, 1).get(0);
+        assertViewChildren(container, mockView);
+    }
+
+    @Test
+    public void returnsContainerStackWithMultipleViews() {
+        final View mockView1 = mock(View.class);
+        final View mockView2 = mock(View.class);
+        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView1);
+        when(rootViewCreator.createRootView(eq(OTHER_VIEW_ID), eq(OTHER_VIEW_NAME))).thenReturn(mockView2);
+
+        final LayoutNode node1 = createContainerNode(VIEW_ID, VIEW_NAME);
+        final LayoutNode node2 = createContainerNode(OTHER_VIEW_ID, OTHER_VIEW_NAME);
+        final LayoutNode outerNode = getContainerStackNode(Arrays.asList(node1, node2));
+
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(outerNode);
+
         assertThat(result).isInstanceOf(ContainerStack.class);
-        assertThat(result.getChildCount()).isEqualTo(1);
-        ViewGroup container = (ViewGroup) result.getChildAt(0);
-        assertThat(container.getChildCount()).isEqualTo(1);
-        assertThat(container.getChildAt(0)).isEqualTo(viewRef.get());
+        List<View> containers = assertViewChildrenCount(result, 2);
+        ViewGroup container1 = (ViewGroup) containers.get(0);
+        ViewGroup container2 = (ViewGroup) containers.get(1);
+        assertViewChildren(container1, mockView1);
+        assertViewChildren(container2, mockView2);
+    }
+
+    private LayoutFactory createLayoutFactory() {
+        return new LayoutFactory(Robolectric.buildActivity(Activity.class).get(), rootViewCreator);
+    }
+
+    private LayoutNode getContainerStackNode(LayoutNode innerNode) {
+        return getContainerStackNode(Arrays.asList(innerNode));
+    }
+
+    private LayoutNode getContainerStackNode(List<LayoutNode> children) {
+        LayoutNode outerNode = new LayoutNode();
+        outerNode.type = "ContainerStack";
+        outerNode.children = children;
+        return outerNode;
+    }
+
+    private LayoutNode createContainerNode() {
+        return createContainerNode(VIEW_ID, VIEW_NAME);
+    }
+
+    private LayoutNode createContainerNode(final String id, final String name) {
+        return new LayoutNode(id, "Container", new HashMap<String, Object>() {{ put("name", name); }});
+    }
+
+    private List<View> assertViewChildrenCount(ViewGroup view, int count) {
+        assertThat(view.getChildCount()).isEqualTo(count);
+
+        final List<View> children = new ArrayList<>(count);
+        for (int i = 0; i < count; i++) {
+            children.add(view.getChildAt(i));
+        }
+        return children;
+    }
+
+    private void assertViewChildren(ViewGroup view, View... children) {
+        final List<View> childViews = assertViewChildrenCount(view, children.length);
+        assertThat(childViews).isEqualTo(Arrays.asList(children));
     }
 }