| // 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/message_loop/message_loop.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 "net/url_request/test_url_fetcher_factory.h" |
| #include "net/url_request/url_request_context_getter.h" |
| #include "net/url_request/url_request_status.h" |
| #include "net/url_request/url_request_test_util.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) |
| : ResourceRequestAllowedNotifier(prefs, disable_network_switch) {} |
| |
| 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, |
| net::URLRequestContextGetter* request_context, |
| const char* disable_network_switch, |
| const ParseJSONCallback& parse_json_callback) |
| : WebResourceService(prefs, |
| web_resource_server, |
| application_locale, |
| last_update_time_pref_name, |
| start_fetch_delay_ms, |
| cache_update_delay_ms, |
| request_context, |
| disable_network_switch, |
| parse_json_callback, |
| TRAFFIC_ANNOTATION_FOR_TESTS){}; |
| |
| void Unpack(const base::DictionaryValue& parsed_json) override{}; |
| }; |
| |
| class WebResourceServiceTest : public testing::Test { |
| public: |
| WebResourceServiceTest() {} |
| |
| void SetUp() override { |
| request_context_getter_ = new net::TestURLRequestContextGetter( |
| base::ThreadTaskRunnerHandle::Get()); |
| 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, request_context_getter_.get(), nullptr, |
| base::Bind(web_resource::WebResourceServiceTest::Parse))); |
| error_message_ = ""; |
| TestResourceRequestAllowedNotifier* notifier = |
| new TestResourceRequestAllowedNotifier(local_state_.get(), nullptr); |
| 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::MessageLoop message_loop_; // needed for TestURLFetcherFactory |
| scoped_refptr<net::URLRequestContextGetter> request_context_getter_; |
| 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 |