components/web_resource/web_resource_service_unittest.cc

// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <memory>
#include <utility>

#include "base/bind.h"
#include "base/test/scoped_task_environment.h"
#include "base/values.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/testing_pref_service.h"
#include "components/web_resource/resource_request_allowed_notifier.h"
#include "components/web_resource/web_resource_service.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
#include "services/network/test/test_network_connection_tracker.h"
#include "services/network/test/test_url_loader_factory.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {
const std::string kTestUrl = "http://www.test.com";
const std::string kCacheUpdatePath = "cache_update_path";
std::string error_message_;
}  // namespace

namespace web_resource {

class TestResourceRequestAllowedNotifier
    : public ResourceRequestAllowedNotifier {
 public:
  TestResourceRequestAllowedNotifier(
      PrefService* prefs,
      const char* disable_network_switch,
      network::NetworkConnectionTracker* network_connection_tracker)
      : ResourceRequestAllowedNotifier(
            prefs,
            disable_network_switch,
            base::BindOnce(
                [](network::NetworkConnectionTracker* tracker) {
                  return tracker;
                },
                network_connection_tracker)) {}

  ResourceRequestAllowedNotifier::State GetResourceRequestsAllowedState()
      override {
    return state_;
  }

  void SetState(ResourceRequestAllowedNotifier::State state) { state_ = state; }

  void NotifyState(ResourceRequestAllowedNotifier::State state) {
    SetState(state);
    SetObserverRequestedForTesting(true);
    MaybeNotifyObserver();
  }

 private:
  ResourceRequestAllowedNotifier::State state_;
};

class TestWebResourceService : public WebResourceService {
 public:
  TestWebResourceService(
      PrefService* prefs,
      const GURL& web_resource_server,
      const std::string& application_locale,
      const char* last_update_time_pref_name,
      int start_fetch_delay_ms,
      int cache_update_delay_ms,
      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
      const char* disable_network_switch,
      const ParseJSONCallback& parse_json_callback,
      network::NetworkConnectionTracker* network_connection_tracker)
      : WebResourceService(prefs,
                           web_resource_server,
                           application_locale,
                           last_update_time_pref_name,
                           start_fetch_delay_ms,
                           cache_update_delay_ms,
                           url_loader_factory,
                           disable_network_switch,
                           parse_json_callback,
                           TRAFFIC_ANNOTATION_FOR_TESTS,
                           base::BindOnce(
                               [](network::NetworkConnectionTracker* tracker) {
                                 return tracker;
                               },
                               network_connection_tracker)) {}

  void Unpack(const base::DictionaryValue& parsed_json) override {}
};

class WebResourceServiceTest : public testing::Test {
 public:
  void SetUp() override {
    test_shared_loader_factory_ =
        base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
            &test_url_loader_factory_);
    local_state_.reset(new TestingPrefServiceSimple());
    local_state_->registry()->RegisterStringPref(kCacheUpdatePath, "0");
    test_web_resource_service_.reset(new TestWebResourceService(
        local_state_.get(), GURL(kTestUrl), "", kCacheUpdatePath.c_str(), 100,
        5000, test_shared_loader_factory_, nullptr,
        base::BindRepeating(web_resource::WebResourceServiceTest::Parse),
        network::TestNetworkConnectionTracker::GetInstance()));
    error_message_ = "";
    TestResourceRequestAllowedNotifier* notifier =
        new TestResourceRequestAllowedNotifier(
            local_state_.get(), nullptr,
            network::TestNetworkConnectionTracker::GetInstance());
    notifier->SetState(ResourceRequestAllowedNotifier::ALLOWED);
    test_web_resource_service_->SetResourceRequestAllowedNotifier(
        std::unique_ptr<ResourceRequestAllowedNotifier>(notifier));
  }

  TestResourceRequestAllowedNotifier* resource_notifier() {
    return static_cast<TestResourceRequestAllowedNotifier*>(
        test_web_resource_service_->resource_request_allowed_notifier_.get());
  }

  bool GetFetchScheduled() {
    return test_web_resource_service_->GetFetchScheduled();
  }

  void CallScheduleFetch(int64_t delay_ms) {
    return test_web_resource_service_->ScheduleFetch(delay_ms);
  }

  static void Parse(const std::string& unsafe_json,
                    const WebResourceService::SuccessCallback& success_callback,
                    const WebResourceService::ErrorCallback& error_callback) {
    std::unique_ptr<base::Value> value;
    if (!error_message_.empty())
      error_callback.Run(error_message_);
    else
      success_callback.Run(std::move(value));
  }

  WebResourceService* web_resource_service() {
    return test_web_resource_service_.get();
  }

  void CallStartFetch() { test_web_resource_service_->StartFetch(); }

 private:
  base::test::ScopedTaskEnvironment task_environment_;
  network::TestURLLoaderFactory test_url_loader_factory_;
  scoped_refptr<network::SharedURLLoaderFactory> test_shared_loader_factory_;
  std::unique_ptr<TestingPrefServiceSimple> local_state_;
  std::unique_ptr<TestWebResourceService> test_web_resource_service_;
};

TEST_F(WebResourceServiceTest, FetchScheduledAfterStartDelayTest) {
  web_resource_service()->StartAfterDelay();
  EXPECT_TRUE(GetFetchScheduled());
}

TEST_F(WebResourceServiceTest, FetchScheduledOnScheduleFetchTest) {
  web_resource_service()->StartAfterDelay();
  resource_notifier()->NotifyState(ResourceRequestAllowedNotifier::ALLOWED);
  EXPECT_TRUE(GetFetchScheduled());
}

TEST_F(WebResourceServiceTest, FetchScheduledOnStartFetchTest) {
  resource_notifier()->NotifyState(
      ResourceRequestAllowedNotifier::DISALLOWED_NETWORK_DOWN);
  CallStartFetch();
  EXPECT_FALSE(GetFetchScheduled());
  resource_notifier()->NotifyState(ResourceRequestAllowedNotifier::ALLOWED);
  EXPECT_TRUE(GetFetchScheduled());
}

}  // namespace web_resource