Issue 5180 - start to inject implementation of WebRequest into JsEngine::ctr

test/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 26 matching lines @@
   class VeryLazyFileSystem : public LazyFileSystem
   {
   public:
     StatResult Stat(const std::string& path) const
     {
       return StatResult();
     }
   };
 
   template<class FileSystem, class LogSystem>
-  class FilterEngineTestGeneric : public BaseJsTest
+  class FilterEngineTestGeneric : public ::testing::Test
   {
   protected:
     FilterEnginePtr filterEngine;
 
     void SetUp() override
     {
-      BaseJsTest::SetUp();
-      jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new FileSystem));
-      jsEngine->SetWebRequest(std::make_shared<LazyWebRequest>());
-      jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LogSystem));
+      JsEngineCreationParameters jsEngineParams;
+      jsEngineParams.fileSystem.reset(new FileSystem());
+      jsEngineParams.logSystem.reset(new LogSystem());
+      jsEngineParams.timer.reset(new NoopTimer());
+      jsEngineParams.webRequest.reset(new NoopWebRequest());
+      auto jsEngine = CreateJsEngine(std::move(jsEngineParams));
       filterEngine = AdblockPlus::FilterEngine::Create(jsEngine);
     }
     void TearDown() override
     {
       // Workaround for issue 5198
       std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
   };
 
   typedef FilterEngineTestGeneric<LazyFileSystem, AdblockPlus::DefaultLogSystem> FilterEngineTest;
@@ skipping 12 matching lines @@
       {
         return response;
       }
     };
 
     std::shared_ptr<MockWebRequest> mockWebRequest;
     FilterEnginePtr filterEngine;
 
     void SetUp()
     {
-      AdblockPlus::AppInfo appInfo;
-      appInfo.name = "test";
-      appInfo.version = "1.0.1";
-      AdblockPlus::JsEnginePtr jsEngine = CreateJsEngine(appInfo);
-      jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new LazyFileSystem));
+      JsEngineCreationParameters jsEngineParams;
+      jsEngineParams.appInfo.name = "test";
+      jsEngineParams.appInfo.version = "1.0.1";
+      jsEngineParams.timer = CreateDefaultTimer();
+      jsEngineParams.fileSystem.reset(new LazyFileSystem());
+      AdblockPlus::JsEnginePtr jsEngine = CreateJsEngine(std::move(jsEngineParams));
       jsEngine->SetWebRequest(mockWebRequest = std::make_shared<MockWebRequest>());
       filterEngine = AdblockPlus::FilterEngine::Create(jsEngine);
     }
   };
 
   class FilterEngineWithFreshFolder : public ::testing::Test
   {
   protected:
     FileSystemPtr fileSystem;
     std::weak_ptr<JsEngine> weakJsEngine;
 
     void SetUp() override
     {
       fileSystem.reset(new DefaultFileSystem());
       // Since there is neither in memory FS nor functionality to work with
       // directories use the hack: manually clean the directory.
       removeFileIfExists("patterns.ini");
       removeFileIfExists("prefs.json");
     }
     JsEnginePtr createJsEngine(const AppInfo& appInfo = AppInfo())
     {
-      auto jsEngine = JsEngine::New(appInfo);
+      JsEngineCreationParameters jsEngineParams;
+      jsEngineParams.appInfo = appInfo;
+      jsEngineParams.fileSystem = fileSystem;
+      jsEngineParams.logSystem.reset(new LazyLogSystem());
+      jsEngineParams.timer.reset(new NoopTimer());
+      jsEngineParams.webRequest.reset(new NoopWebRequest());
+      auto jsEngine = CreateJsEngine(std::move(jsEngineParams));
       weakJsEngine = jsEngine;
-      jsEngine->SetFileSystem(fileSystem);
-      jsEngine->SetWebRequest(std::make_shared<LazyWebRequest>());
-      jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LazyLogSystem()));
       return jsEngine;
     }
     void TearDown() override
     {
       removeFileIfExists("patterns.ini");
       removeFileIfExists("prefs.json");
       fileSystem.reset();
     }
     void removeFileIfExists(const std::string& path)
     {
@@ skipping 11 matching lines @@
         {
           return false;
         }
       };
       int i = 5;
       while ((i-- > 0 && weakJsEngine.lock()) || !safeRemove())
         std::this_thread::sleep_for(std::chrono::seconds(2));
     }
   };
 
-  class FilterEngineIsAllowedConnectionTest : public BaseJsTest
+  class FilterEngineIsAllowedConnectionTest : public ::testing::Test
   {
     class MockWebRequest : public LazyWebRequest
     {
     public:
       std::map</*beginning of url*/std::string, AdblockPlus::ServerResponse> responses;
 
       AdblockPlus::ServerResponse GET(const std::string& url,
         const AdblockPlus::HeaderList& requestHeaders) const
       {
         for (const auto& response : responses)
@@ skipping 40 matching lines @@
       bool isConnectionAllowed;
       struct
       {
         std::string url;
         std::mutex mutex;
         std::condition_variable cv;
       } downloadStatusChanged;
     };
     std::shared_ptr<SharedData> data;
     FilterEnginePtr filterEngine;
+    JsEnginePtr jsEngine;
 
     void SetUp()
     {
       data = std::make_shared<SharedData>();
-      BaseJsTest::SetUp();
-      jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new LazyFileSystem()));
+      JsEngineCreationParameters jsEngineParams;
+      jsEngineParams.logSystem.reset(new LazyLogSystem());
+      jsEngineParams.fileSystem.reset(new LazyFileSystem());
+      jsEngineParams.timer = CreateDefaultTimer();
+      jsEngine = CreateJsEngine(std::move(jsEngineParams));
       jsEngine->SetWebRequest(webRequest = std::make_shared<MockWebRequest>());
-      jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LazyLogSystem()));
 
       subscriptionUrlPrefix = "http://example";
       ServerResponse exampleSubscriptionResponse;
       exampleSubscriptionResponse.responseStatus = 200;
       exampleSubscriptionResponse.status = IWebRequest::NS_OK;
       exampleSubscriptionResponse.responseText = "[Adblock Plus 2.0]\n||example.com";
       webRequest->responses.emplace(subscriptionUrlPrefix, exampleSubscriptionResponse);
       createParams.preconfiguredPrefs.emplace("first_run_subscription_auto_select", jsEngine->NewValue(false));
       data->isConnectionAllowed = true;
       auto closure = data;
@@ skipping 900 matching lines @@
     filterEngine->SetAllowedConnectionType(&testConnection);
     auto subscription = EnsureExampleSubscriptionAndForceUpdate("subB");
     EXPECT_EQ("synchronize_ok", subscription.GetProperty("downloadStatus").AsString());
     EXPECT_EQ(1u, subscription.GetProperty("filters").AsList().size());
     auto capturedConnectionTypes = data->capturedConnectionTypes.GetStrings();
     ASSERT_EQ(1u, capturedConnectionTypes.size());
     EXPECT_TRUE(capturedConnectionTypes[0].first);
     EXPECT_EQ(testConnection, capturedConnectionTypes[0].second);
   }
 }