| // 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 "components/subresource_filter/core/common/document_subresource_filter.h" |
| |
| #include "base/files/file.h" |
| #include "base/macros.h" |
| #include "base/strings/string_piece.h" |
| #include "components/subresource_filter/core/common/memory_mapped_ruleset.h" |
| #include "components/subresource_filter/core/common/test_ruleset_creator.h" |
| #include "components/subresource_filter/core/common/test_ruleset_utils.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "url/gurl.h" |
| #include "url/origin.h" |
| |
| namespace subresource_filter { |
| |
| namespace proto = url_pattern_index::proto; |
| |
| namespace { |
| |
| constexpr auto kDryRun = mojom::ActivationLevel::kDryRun; |
| constexpr auto kEnabled = mojom::ActivationLevel::kEnabled; |
| |
| constexpr auto kImageType = proto::ELEMENT_TYPE_IMAGE; |
| constexpr auto kSubdocumentType = proto::ELEMENT_TYPE_SUBDOCUMENT; |
| |
| constexpr const char kTestAlphaURL[] = "http://example.com/alpha"; |
| constexpr const char kTestAlphaDataURI[] = "data:text/plain,alpha"; |
| constexpr const char kTestAlphaWSURI[] = "ws://example.com/alpha"; |
| constexpr const char kTestBetaURL[] = "http://example.com/beta"; |
| |
| constexpr const char kTestAlphaURLPathSuffix[] = "alpha"; |
| |
| } // namespace |
| |
| // Tests for DocumentSubresourceFilter class. ---------------------------------- |
| |
| class DocumentSubresourceFilterTest : public ::testing::Test { |
| public: |
| DocumentSubresourceFilterTest() {} |
| |
| protected: |
| void SetUp() override { |
| ASSERT_NO_FATAL_FAILURE( |
| SetTestRulesetToDisallowURLsWithPathSuffix(kTestAlphaURLPathSuffix)); |
| } |
| |
| void SetTestRulesetToDisallowURLsWithPathSuffix(base::StringPiece suffix) { |
| testing::TestRulesetPair test_ruleset_pair; |
| ASSERT_NO_FATAL_FAILURE( |
| test_ruleset_creator_.CreateRulesetToDisallowURLsWithPathSuffix( |
| suffix, &test_ruleset_pair)); |
| ruleset_ = MemoryMappedRuleset::CreateAndInitialize( |
| testing::TestRuleset::Open(test_ruleset_pair.indexed)); |
| } |
| |
| const MemoryMappedRuleset* ruleset() { return ruleset_.get(); } |
| |
| private: |
| testing::TestRulesetCreator test_ruleset_creator_; |
| scoped_refptr<const MemoryMappedRuleset> ruleset_; |
| |
| DISALLOW_COPY_AND_ASSIGN(DocumentSubresourceFilterTest); |
| }; |
| |
| TEST_F(DocumentSubresourceFilterTest, DryRun) { |
| mojom::ActivationState activation_state; |
| activation_state.activation_level = kDryRun; |
| activation_state.measure_performance = true; |
| DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset()); |
| |
| EXPECT_EQ(LoadPolicy::WOULD_DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType)); |
| EXPECT_EQ( |
| LoadPolicy::WOULD_DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaWSURI), proto::ELEMENT_TYPE_OTHER)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType)); |
| EXPECT_EQ(LoadPolicy::WOULD_DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType)); |
| |
| const auto& statistics = filter.statistics(); |
| EXPECT_EQ(6, statistics.num_loads_total); |
| EXPECT_EQ(5, statistics.num_loads_evaluated); |
| EXPECT_EQ(3, statistics.num_loads_matching_rules); |
| EXPECT_EQ(0, statistics.num_loads_disallowed); |
| } |
| |
| TEST_F(DocumentSubresourceFilterTest, MatchingRuleDryRun) { |
| mojom::ActivationState activation_state; |
| activation_state.activation_level = kDryRun; |
| activation_state.measure_performance = false; |
| DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset()); |
| |
| EXPECT_NE(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaURL), kImageType)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaDataURI), kImageType)); |
| EXPECT_NE(nullptr, filter.FindMatchingUrlRule(GURL(kTestAlphaWSURI), |
| proto::ELEMENT_TYPE_OTHER)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestBetaURL), kImageType)); |
| EXPECT_NE(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaURL), kSubdocumentType)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestBetaURL), kSubdocumentType)); |
| } |
| |
| TEST_F(DocumentSubresourceFilterTest, Enabled) { |
| auto test_impl = [this](bool measure_performance) { |
| mojom::ActivationState activation_state; |
| activation_state.activation_level = kEnabled; |
| activation_state.measure_performance = measure_performance; |
| DocumentSubresourceFilter filter(url::Origin(), activation_state, |
| ruleset()); |
| |
| EXPECT_EQ(LoadPolicy::DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType)); |
| EXPECT_EQ( |
| LoadPolicy::DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaWSURI), proto::ELEMENT_TYPE_OTHER)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType)); |
| EXPECT_EQ(LoadPolicy::DISALLOW, |
| filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType)); |
| EXPECT_EQ(LoadPolicy::ALLOW, |
| filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType)); |
| |
| const auto& statistics = filter.statistics(); |
| EXPECT_EQ(6, statistics.num_loads_total); |
| EXPECT_EQ(5, statistics.num_loads_evaluated); |
| EXPECT_EQ(3, statistics.num_loads_matching_rules); |
| EXPECT_EQ(3, statistics.num_loads_disallowed); |
| |
| if (!measure_performance) { |
| EXPECT_TRUE(statistics.evaluation_total_cpu_duration.is_zero()); |
| EXPECT_TRUE(statistics.evaluation_total_wall_duration.is_zero()); |
| } |
| // Otherwise, don't expect |total_duration| to be non-zero, although it |
| // practically is (when timer is supported). |
| }; |
| |
| test_impl(true /* measure_performance */); |
| test_impl(false /* measure_performance */); |
| } |
| |
| TEST_F(DocumentSubresourceFilterTest, MatchingRuleEnabled) { |
| mojom::ActivationState activation_state; |
| activation_state.activation_level = kEnabled; |
| activation_state.measure_performance = false; |
| DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset()); |
| |
| EXPECT_NE(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaURL), kImageType)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaDataURI), kImageType)); |
| EXPECT_NE(nullptr, filter.FindMatchingUrlRule(GURL(kTestAlphaWSURI), |
| proto::ELEMENT_TYPE_OTHER)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestBetaURL), kImageType)); |
| EXPECT_NE(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestAlphaURL), kSubdocumentType)); |
| EXPECT_EQ(nullptr, |
| filter.FindMatchingUrlRule(GURL(kTestBetaURL), kSubdocumentType)); |
| } |
| |
| } // namespace subresource_filter |