blob: b8ab45da17ddcd3f8e8b412cd463e16e1ff79d62 [file] [log] [blame]
// 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