Integrate top level ReactInstanceManager changes

ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerImpl.java

@@ -581,7 +581,7 @@ private void detachViewFromInstance(
       CatalystInstance catalystInstance) {
     UiThreadUtil.assertOnUiThread();
     catalystInstance.getJSModule(AppRegistry.class)
-        .unmountApplicationComponentAtRootTag(rootView.getId());
+            .unmountApplicationComponentAtRootTag(rootView.getId());
   }
 
   private void tearDownReactContext(ReactContext reactContext) {

ReactWindows/Playground/Playground.csproj

@@ -135,6 +135,11 @@
       <Name>ReactNative</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Facebook.CSSLayout">
+      <HintPath>..\References\Facebook.CSSLayout.dll</HintPath>
+    </Reference>
+  </ItemGroup>
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
     <VisualStudioVersion>14.0</VisualStudioVersion>
   </PropertyGroup>

ReactWindows/ReactNative.Tests/Bridge/CatalystInstanceTests.cs

@@ -32,6 +32,7 @@ public async Task CatalystInstance_GetModules()
                 Registry = registry,
                 JavaScriptModulesConfig = jsConfig,
                 JavaScriptExecutor = executor,
+                BundleLoader = JavaScriptBundleLoader.CreateFileLoader("ms-appx:///Resources/test.js"),
                 NativeModuleCallExceptionHandler = _ => { }
             };
 
@@ -63,6 +64,7 @@ public async Task CatalystInstance_Initialize_Dispose()
                 Registry = registry,
                 JavaScriptModulesConfig = jsConfig,
                 JavaScriptExecutor = executor,
+                BundleLoader = JavaScriptBundleLoader.CreateFileLoader("ms-appx:///Resources/test.js"),
                 NativeModuleCallExceptionHandler = _ => { },
             };
 
@@ -108,6 +110,7 @@ public async Task CatalystInstance_ExceptionHandled_Disposes()
                 Registry = registry,
                 JavaScriptModulesConfig = jsConfig,
                 JavaScriptExecutor = executor,
+                BundleLoader = JavaScriptBundleLoader.CreateFileLoader("ms-appx:///Resources/test.js"),
                 NativeModuleCallExceptionHandler = handler,
             };
 

ReactWindows/ReactNative.Tests/Bridge/JavaScriptModuleRegistryTests.cs

@@ -2,8 +2,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using ReactNative.Bridge;
-using ReactNative.Modules.Core;
 using ReactNative.UIManager;
+using ReactNative.UIManager.Events;
 using System;
 using System.Collections.Generic;
 using System.Threading;

ReactWindows/ReactNative.Tests/Bridge/JavaScriptModulesConfigTests.cs

@@ -21,9 +21,61 @@ public void JavaScriptModulesConfig_MethodOverrides_ThrowsNotSupported()
         [TestMethod]
         public void JavaScriptModulesConfig_WriteModuleDefinitions()
         {
-            var builder = new JavaScriptModulesConfig.Builder();
-            builder.Add<TestJavaScriptModule>();
-            var config = builder.Build();
+            var config = new JavaScriptModulesConfig.Builder()
+                .Add<TestJavaScriptModule>()
+                .Build();
+
+            using (var stringWriter = new StringWriter())
+            {
+                using (var writer = new JsonTextWriter(stringWriter))
+                {
+                    config.WriteModuleDescriptions(writer);
+                }
+
+                var actual = stringWriter.ToString();
+                var expected = JObject.FromObject(
+                    new Map
+                    {
+                        {
+                            "TestJavaScriptModule",
+                            new Map
+                            {
+                                { "moduleID", 0 },
+                                {
+                                    "methods",
+                                    new Map
+                                    {
+                                        {
+                                            "Bar",
+                                            new Map
+                                            {
+                                                { "methodID", 0 },
+                                            }
+                                        },
+                                        {
+                                            "Foo",
+                                            new Map
+                                            {
+                                                { "methodID", 1 },
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ).ToString(Formatting.None);
+
+                Assert.AreEqual(expected, actual);
+            }
+        }
+
+        [TestMethod]
+        public void JavaScriptModulesConfig_NonGenericAdd_WriteModuleDefinitions()
+        {
+            var config = new JavaScriptModulesConfig.Builder()
+                .Add(typeof(TestJavaScriptModule))
+                .Build();
 
             using (var stringWriter = new StringWriter())
             {
@@ -69,6 +121,29 @@ public void JavaScriptModulesConfig_WriteModuleDefinitions()
                 Assert.AreEqual(expected, actual);
             }
         }
+
+
+        [TestMethod]
+        public void JavaScriptModulesConfig_NonGenericAdd()
+        {
+            var builder = new JavaScriptModulesConfig.Builder();
+
+            AssertEx.Throws<ArgumentException>(
+                () => builder.Add(typeof(JavaScriptModuleBase)),
+                ex => Assert.AreEqual("moduleType", ex.ParamName));
+
+            AssertEx.Throws<ArgumentException>(
+                () => builder.Add(typeof(IDerivedJavaScriptModule)),
+                ex => Assert.AreEqual("moduleType", ex.ParamName));
+
+            AssertEx.Throws<ArgumentException>(
+                () => builder.Add(typeof(object)),
+                ex => Assert.AreEqual("moduleType", ex.ParamName));
+
+            AssertEx.Throws<ArgumentException>(
+                () => builder.Add(typeof(NoConstructorJavaScriptModule)),
+                ex => Assert.AreEqual("moduleType", ex.ParamName));
+        }
     }
 
     public class Map : Dictionary<string, object> { }
@@ -87,6 +162,16 @@ public void Foo(int x)
         }
     }
 
+    public interface IDerivedJavaScriptModule : IJavaScriptModule
+    {
+
+    }
+
+    public class NoConstructorJavaScriptModule : JavaScriptModuleBase
+    {
+        private NoConstructorJavaScriptModule() { }
+    }
+
     public class TestJavaScriptModule : JavaScriptModuleBase
     {
         public void Bar()

ReactWindows/ReactNative.Tests/Bridge/ReactContextNativeModuleBaseTests.cs

@@ -0,0 +1,38 @@
+using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
+using ReactNative.Bridge;
+using System;
+
+namespace ReactNative.Tests.Bridge
+{
+    [TestClass]
+    public class ReactContextNativeModuleBaseTests
+    {
+        [TestMethod]
+        public void ReactContextNativeModuleBase_ArgumentChecks()
+        {
+            AssertEx.Throws<ArgumentNullException>(
+                () => new TestModule(null),
+                ex => Assert.AreEqual("reactContext", ex.ParamName));
+
+            var context = new ReactApplicationContext();
+            var module = new TestModule(context);
+            Assert.AreSame(context, module.Context);
+        }
+
+        class TestModule : ReactContextNativeModuleBase
+        {
+            public TestModule(ReactApplicationContext reactContext)
+                : base(reactContext)
+            {
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    return "Test";
+                }
+            }
+        }
+    }
+}

ReactWindows/ReactNative.Tests/Internal/Constants/DictionaryHelpers.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+
+namespace ReactNative.Tests.Constants
+{
+    static class DictionaryHelpers
+    {
+        public static TValue Get<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
+        {
+            var result = default(TValue);
+            if (dictionary.TryGetValue(key, out result))
+            {
+                return result;
+            }
+
+            return default(TValue);
+        }
+
+        public static IReadOnlyDictionary<string, object> AsMap(this object value)
+        {
+            return value as IReadOnlyDictionary<string, object>;
+        }
+
+        public static object GetValue(this object value, string key)
+        {
+            var map = value.AsMap();
+            if (map == null)
+            {
+                return null;
+            }
+
+            return map.Get(key);
+        }
+
+        public static IReadOnlyDictionary<string, object> GetMap(this object value, string key)
+        {
+            return GetValue(value, key).AsMap();
+        }
+    }
+}

ReactWindows/ReactNative.Tests/Internal/JavaScriptHelpers.cs

@@ -62,6 +62,8 @@ public static async Task Initialize(ChakraJavaScriptExecutor executor, IMessageQ
 
             await jsQueueThread.CallOnQueue(() =>
             {
+                executor.Initialize();
+
                 foreach (var script in scripts)
                 {
                     executor.RunScript(script);

ReactWindows/ReactNative.Tests/Internal/MockCatalystInstance.cs

@@ -1,5 +1,6 @@
 using Newtonsoft.Json.Linq;
 using ReactNative.Bridge;
+using ReactNative.Bridge.Queue;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -32,6 +33,14 @@ public MockCatalystInstance(Action<int, JArray> callback, Action<int, int, JArra
             _function = function;
         }
 
+        public bool IsDisposed
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
         public IEnumerable<INativeModule> NativeModules
         {
             get
@@ -40,6 +49,14 @@ public IEnumerable<INativeModule> NativeModules
             }
         }
 
+        public ICatalystQueueConfiguration QueueConfiguration
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
         public T GetNativeModule<T>() where T : INativeModule
         {
             throw new NotImplementedException();
@@ -64,5 +81,10 @@ public void InvokeFunction(int moduleId, int methodId, JArray arguments, string
         {
             _function(moduleId, methodId, arguments, tracingName);
         }
+
+        public void Dispose()
+        {
+            throw new NotImplementedException();
+        }
     }
 }

ReactWindows/ReactNative.Tests/Internal/MockEvent.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json.Linq;
+using ReactNative.UIManager.Events;
+using System;
+
+namespace ReactNative.Tests
+{
+    class MockEvent : Event
+    {
+        private readonly string _eventName;
+        private readonly JObject _eventArgs;
+
+        public MockEvent(int viewTag, TimeSpan timestamp, string eventName, JObject eventArgs)
+            : base(viewTag, timestamp)
+        {
+            _eventName = eventName;
+            _eventArgs = eventArgs;
+        }
+
+        public override string EventName
+        {
+            get
+            {
+                return _eventName;
+            }
+        }
+
+        public override void Dispatch(RCTEventEmitter eventEmitter)
+        {
+            eventEmitter.receiveEvent(ViewTag, EventName, _eventArgs);
+        }
+    }
+}

ReactWindows/ReactNative.Tests/Internal/MockJavaScriptExecutor.cs

@@ -7,30 +7,40 @@ namespace ReactNative.Tests
     class MockJavaScriptExecutor : IJavaScriptExecutor
     {
         private readonly Func<string, string, JArray, JToken> _onCall;
+        private readonly Action<string> _runScript;
         private readonly Action<string, JToken> _onSetGlobalVariable;
         private readonly Action _onDispose;
 
         public MockJavaScriptExecutor(
             Func<string, string, JArray, JToken> onCall)
-            : this(onCall, (_, __) => { }, () => { })
+            : this(onCall, _ => { }, (_, __) => { }, () => { })
         {
         }
 
         public MockJavaScriptExecutor(
             Func<string, string, JArray, JToken> onCall,
+            Action<string> runScript,
             Action<string, JToken> onSetGlobalVariable,
             Action onDispose)
         {
             _onCall = onCall;
+            _runScript = runScript;
             _onSetGlobalVariable = onSetGlobalVariable;
             _onDispose = onDispose;
         }
 
+        public void Initialize() { }
+
         public JToken Call(string moduleName, string methodName, JArray arguments)
         {
             return _onCall(moduleName, methodName, arguments);
         }
 
+        public void RunScript(string script)
+        {
+            _runScript(script);
+        }
+
         public void SetGlobalVariable(string propertyName, JToken value)
         {
             _onSetGlobalVariable(propertyName, value);
@@ -40,6 +50,5 @@ public void Dispose()
         {
             _onDispose();
         }
-
     }
 }