Enable WebSocketModule unit tests

change/react-native-windows-2020-04-09-16-51-25-wsmodule_unittests.json

@@ -0,0 +1,7 @@
+{
+  "type": "none",
+  "packageName": "react-native-windows",
+  "email": "julio@rochsquadron.net",
+  "dependentChangeType": "none",
+  "date": "2020-04-09T23:51:25.594Z"
+}

change/react-native-windows-2020-04-09-16-51-56-wsmodule_unittests.json

@@ -0,0 +1,8 @@
+{
+  "type": "none",
+  "comment": "Allow WebSocketModule to use custom resource factory",
+  "packageName": "react-native-windows",
+  "email": "julio@rochsquadron.net",
+  "dependentChangeType": "none",
+  "date": "2020-04-09T23:51:56.846Z"
+}

vnext/Desktop.UnitTests/InstanceMocks.cpp

@@ -0,0 +1,98 @@
+#include "InstanceMocks.h"
+
+#include <cxxreact/ModuleRegistry.h>
+
+using namespace facebook::react;
+
+using folly::dynamic;
+using std::function;
+using std::make_shared;
+using std::make_unique;
+using std::shared_ptr;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace Microsoft::React::Test {
+#pragma region MockMessageQueueThread
+void MockMessageQueueThread::runOnQueue(function<void()> &&work) /*override*/
+{
+  work();
+}
+
+void MockMessageQueueThread::runOnQueueSync(function<void()> &&work) /*override*/
+{
+  work();
+}
+
+void MockMessageQueueThread::quitSynchronous() /*override*/ {}
+#pragma endregion // MockMessageQueueThread
+
+#pragma region MockInstanceCallback
+
+void MockInstanceCallback::onBatchComplete() /*override*/ {}
+void MockInstanceCallback::incrementPendingJSCalls() /*override*/ {}
+void MockInstanceCallback::decrementPendingJSCalls() /*override*/ {}
+
+#pragma endregion // MockInstanceCallback
+
+#pragma region MockJSExecutor
+
+void MockJSExecutor::loadApplicationScript(unique_ptr<const JSBigString> script, string sourceURL) {}
+void MockJSExecutor::setBundleRegistry(unique_ptr<RAMBundleRegistry> bundleRegistry) {}
+void MockJSExecutor::registerBundle(uint32_t bundleId, const string &bundlePath) {}
+
+void MockJSExecutor::callFunction(const string &moduleId, const string &methodId, const dynamic &arguments) {
+  if (CallFunctionMock) {
+    CallFunctionMock(moduleId, methodId, arguments);
+  }
+}
+
+void MockJSExecutor::invokeCallback(const double callbackId, const dynamic &arguments) {}
+void MockJSExecutor::setGlobalVariable(string propName, unique_ptr<const JSBigString> jsonValue) {}
+void *MockJSExecutor::getJavaScriptContext() {
+  return nullptr;
+}
+
+bool MockJSExecutor::isInspectable() {
+  return false;
+}
+std::string MockJSExecutor::getDescription() {
+  return {};
+}
+void MockJSExecutor::handleMemoryPressure(__unused int pressureLevel) {}
+void MockJSExecutor::destroy() {}
+void MockJSExecutor::flush() {}
+
+#pragma endregion // MockJSExecutor
+
+#pragma region MockJSExecutorFactory
+
+unique_ptr<JSExecutor> MockJSExecutorFactory::createJSExecutor(
+    shared_ptr<ExecutorDelegate> delegate,
+    shared_ptr<MessageQueueThread> jsQueue) /*override*/
+{
+  if (CreateJSExecutorMock) {
+    return CreateJSExecutorMock(delegate, jsQueue);
+  }
+
+  return make_unique<MockJSExecutor>();
+}
+
+#pragma endregion // MockJSExecutorFactory
+
+shared_ptr<Instance> CreateMockInstance(shared_ptr<JSExecutorFactory> jsef) {
+  auto instance = make_shared<Instance>();
+  auto callback = make_unique<MockInstanceCallback>();
+  auto jsQueue = make_shared<MockMessageQueueThread>();
+  auto moduleRegistry = make_shared<ModuleRegistry>(
+      vector<unique_ptr<NativeModule>>(), // modules
+      nullptr // moduleNotFoundCallback
+  );
+
+  instance->initializeBridge(std::move(callback), jsef, jsQueue, moduleRegistry);
+
+  return instance;
+}
+
+} // namespace Microsoft::React::Test

vnext/Desktop.UnitTests/InstanceMocks.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <cxxreact/Instance.h>
+#include <cxxreact/JSBigString.h>
+#include <cxxreact/JSExecutor.h>
+#include <cxxreact/MessageQueueThread.h>
+#include <cxxreact/RAMBundleRegistry.h>
+
+namespace Microsoft::React::Test {
+std::shared_ptr<facebook::react::Instance> CreateMockInstance(std::shared_ptr<facebook::react::JSExecutorFactory> jsef);
+
+class MockMessageQueueThread : public facebook::react::MessageQueueThread {
+ public:
+#pragma region MessageQueueThread overrides
+
+  void runOnQueue(std::function<void()> &&) override;
+
+  void runOnQueueSync(std::function<void()> &&) override;
+
+  void quitSynchronous() override;
+
+#pragma endregion // MessageQueueThread overrides
+};
+
+class MockInstanceCallback : public facebook::react::InstanceCallback {
+ public:
+#pragma region InstanceCallback overrides
+
+  void onBatchComplete() override;
+  void incrementPendingJSCalls() override;
+  void decrementPendingJSCalls() override;
+
+#pragma endregion // InstanceCallback overrides
+};
+
+class MockJSExecutor : public facebook::react::JSExecutor {
+ public:
+  std::function<void(const std::string &, const std::string &, const folly::dynamic &)> CallFunctionMock;
+
+#pragma region JSExecutor overrides
+
+  void loadApplicationScript(std::unique_ptr<const facebook::react::JSBigString> script, std::string sourceURL)
+      override;
+
+  void setBundleRegistry(std::unique_ptr<facebook::react::RAMBundleRegistry> bundleRegistry) override;
+
+  void registerBundle(uint32_t bundleId, const std::string &bundlePath) override;
+
+  void callFunction(const std::string &moduleId, const std::string &methodId, const folly::dynamic &arguments) override;
+
+  void invokeCallback(const double callbackId, const folly::dynamic &arguments) override;
+
+  void setGlobalVariable(std::string propName, std::unique_ptr<const facebook::react::JSBigString> jsonValue) override;
+
+  void *getJavaScriptContext() override;
+
+  bool isInspectable() override;
+
+  std::string getDescription() override;
+
+  void handleMemoryPressure(__unused int pressureLevel) override;
+
+  void destroy() override;
+
+  void flush() override;
+
+#pragma endregion // JSExecutor overrides
+};
+
+class MockJSExecutorFactory : public facebook::react::JSExecutorFactory {
+ public:
+  std::function<std::unique_ptr<facebook::react::JSExecutor>(
+      std::shared_ptr<facebook::react::ExecutorDelegate>,
+      std::shared_ptr<facebook::react::MessageQueueThread>)>
+      CreateJSExecutorMock;
+
+#pragma region JSExecutorFactory overrides
+
+  std::unique_ptr<facebook::react::JSExecutor> createJSExecutor(
+      std::shared_ptr<facebook::react::ExecutorDelegate> delegate,
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) override;
+
+#pragma endregion // JSExecutorFactory overrides
+};
+
+} // namespace Microsoft::React::Test

vnext/Desktop.UnitTests/React.Windows.Desktop.UnitTests.vcxproj

@@ -87,12 +87,14 @@
     <ClCompile Include="EmptyUIManagerModule.cpp" />
     <ClCompile Include="LayoutAnimationTests.cpp" />
     <ClCompile Include="MemoryMappedBufferTests.cpp" />
+    <ClCompile Include="InstanceMocks.cpp" />
     <ClCompile Include="UnicodeConversionTest.cpp" />
     <ClCompile Include="UnicodeTestStrings.cpp" />
     <ClCompile Include="StringConversionTest_Desktop.cpp" />
     <ClCompile Include="UIManagerModuleTest.cpp" />
     <ClCompile Include="UtilsTest.cpp" />
     <ClCompile Include="WebSocketJSExecutorTest.cpp" />
+    <ClCompile Include="WebSocketMocks.cpp" />
     <ClCompile Include="WebSocketModuleTest.cpp" />
     <ClCompile Include="WebSocketTest.cpp" />
   </ItemGroup>
@@ -104,7 +106,9 @@
   <ItemGroup>
     <ClInclude Include="AsyncStorageTestClass.h" />
     <ClInclude Include="EmptyUIManagerModule.h" />
+    <ClInclude Include="InstanceMocks.h" />
     <ClInclude Include="UnicodeTestStrings.h" />
+    <ClInclude Include="WebSocketMocks.h" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Desktop\React.Windows.Desktop.vcxproj">

vnext/Desktop.UnitTests/React.Windows.Desktop.UnitTests.vcxproj.filters

@@ -46,6 +46,12 @@
     <ClCompile Include="MemoryMappedBufferTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="WebSocketMocks.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="InstanceMocks.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
@@ -68,5 +74,11 @@
     <ClInclude Include="UnicodeTestStrings.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="WebSocketMocks.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="InstanceMocks.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

vnext/Desktop.UnitTests/WebSocketMocks.cpp

@@ -0,0 +1,43 @@
+#include "WebSocketMocks.h"
+
+using std::function;
+using std::string;
+
+namespace Microsoft::React::Test {
+#pragma region IWebSocketResource overrides
+
+void MockWebSocketResource::Connect(const Protocols &, const Options &) /*override*/
+{
+  m_onConnect();
+}
+
+void MockWebSocketResource::Ping() /*override*/ {}
+
+void MockWebSocketResource::Send(const string &) /*override*/ {}
+
+void MockWebSocketResource::SendBinary(const string &) /*override*/ {}
+
+void MockWebSocketResource::Close(CloseCode, const string &) /*override*/ {}
+
+IWebSocketResource::ReadyState MockWebSocketResource::GetReadyState() const /*override*/
+{
+  return ReadyState::Open;
+}
+
+void MockWebSocketResource::SetOnConnect(function<void()> &&onConnect) /*override*/
+{
+  m_onConnect = std::move(onConnect);
+}
+
+void MockWebSocketResource::SetOnPing(function<void()> &&) /*override*/ {}
+
+void MockWebSocketResource::SetOnSend(function<void(size_t)> &&) /*override*/ {}
+
+void MockWebSocketResource::SetOnMessage(function<void(size_t, const string &)> &&) /*override*/ {}
+
+void MockWebSocketResource::SetOnClose(function<void(CloseCode, const string &)> &&) /*override*/ {}
+
+void MockWebSocketResource::SetOnError(function<void(Error &&)> &&) /*override*/ {}
+
+#pragma endregion IWebSocketResource overrides
+} // namespace Microsoft::React::Test

vnext/Desktop.UnitTests/WebSocketMocks.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <IWebSocketResource.h>
+
+namespace Microsoft::React::Test {
+struct MockWebSocketResource : public IWebSocketResource {
+#pragma region IWebSocketResource overrides
+
+  void Connect(const Protocols &, const Options &) override;
+
+  void Ping() override;
+
+  void Send(const std::string &) override;
+
+  void SendBinary(const std::string &) override;
+
+  void Close(CloseCode, const std::string &) override;
+
+  ReadyState GetReadyState() const override;
+
+  void SetOnConnect(std::function<void()> &&onConnect) override;
+
+  void SetOnPing(std::function<void()> &&) override;
+
+  void SetOnSend(std::function<void(size_t)> &&) override;
+
+  void SetOnMessage(std::function<void(size_t, const std::string &)> &&) override;
+
+  void SetOnClose(std::function<void(CloseCode, const std::string &)> &&) override;
+
+  void SetOnError(std::function<void(Error &&)> &&) override;
+
+#pragma endregion IWebSocketResource overrides
+
+ private:
+  std::function<void()> m_onConnect;
+};
+
+} // namespace Microsoft::React::Test