Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(250)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/safe_browsing/safe_browsing_database_unittest.cc

Issue 835523002: Add support for goog-csdinclusionwhite-sha256 in SafeBrowsingDatabase. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@##python_fix
Patch Set: fix tests post merge Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/safe_browsing/safe_browsing_database.cc ('k') | chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
diff --git a/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc b/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
index f2f920a415f9bcf7cc0d55db7109e2cc24e52d7a..b5fc8723d489a4ab1191a7655b2c66bd8d5fbfe5 100644
--- a/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
@@ -278,6 +278,8 @@ class SafeBrowsingDatabaseTest : public PlatformTest {
SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
SafeBrowsingStoreFile* download_whitelist_store =
new SafeBrowsingStoreFile();
+ SafeBrowsingStoreFile* inclusion_whitelist_store =
+ new SafeBrowsingStoreFile();
SafeBrowsingStoreFile* extension_blacklist_store =
new SafeBrowsingStoreFile();
SafeBrowsingStoreFile* side_effect_free_whitelist_store =
@@ -290,6 +292,7 @@ class SafeBrowsingDatabaseTest : public PlatformTest {
download_store,
csd_whitelist_store,
download_whitelist_store,
+ inclusion_whitelist_store,
extension_blacklist_store,
side_effect_free_whitelist_store,
ip_blacklist_store,
@@ -333,7 +336,7 @@ class SafeBrowsingDatabaseTest : public PlatformTest {
};
// Tests retrieving list name information.
-TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowse) {
+TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
std::vector<SBListChunkRanges> lists;
ScopedVector<SBChunkData> chunks;
@@ -395,7 +398,7 @@ TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowse) {
EXPECT_EQ("200-201", lists[1].subs);
}
-TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
+TEST_F(SafeBrowsingDatabaseTest, ListNames) {
ScopedVector<SBChunkData> chunks;
std::vector<SBListChunkRanges> lists;
@@ -422,6 +425,11 @@ TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks.get());
chunks.clear();
+ chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/"));
+ database_->InsertChunks(safe_browsing_util::kInclusionWhitelist,
+ chunks.get());
+
+ chunks.clear();
chunks.push_back(AddChunkFullHashValue(8,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
@@ -429,17 +437,22 @@ TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
chunks.get());
chunks.clear();
- chunks.push_back(AddChunkHashedIpValue(9, "::ffff:192.168.1.0", 120));
+ chunks.push_back(AddChunkFullHashValue(9, "www.sideeffectfree.com"));
+ database_->InsertChunks(safe_browsing_util::kSideEffectFreeWhitelist,
+ chunks.get());
+
+ chunks.clear();
+ chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120));
database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
chunks.clear();
- chunks.push_back(AddChunkPrefixValue(10, "www.unwanted.com/software.html"));
+ chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html"));
database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get());
database_->UpdateFinished(true);
GetListsInfo(&lists);
- ASSERT_EQ(9U, lists.size());
+ ASSERT_EQ(10U, lists.size());
EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
EXPECT_EQ("1", lists[0].adds);
EXPECT_TRUE(lists[0].subs.empty());
@@ -455,15 +468,21 @@ TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name);
EXPECT_EQ("6", lists[4].adds);
EXPECT_TRUE(lists[4].subs.empty());
- EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[5].name);
- EXPECT_EQ("8", lists[5].adds);
+ EXPECT_EQ(safe_browsing_util::kInclusionWhitelist, lists[5].name);
+ EXPECT_EQ("7", lists[5].adds);
EXPECT_TRUE(lists[5].subs.empty());
- EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name);
+ EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[6].name);
+ EXPECT_EQ("8", lists[6].adds);
+ EXPECT_TRUE(lists[6].subs.empty());
+ EXPECT_EQ(safe_browsing_util::kSideEffectFreeWhitelist, lists[7].name);
EXPECT_EQ("9", lists[7].adds);
EXPECT_TRUE(lists[7].subs.empty());
- EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name);
+ EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[8].name);
EXPECT_EQ("10", lists[8].adds);
EXPECT_TRUE(lists[8].subs.empty());
+ EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[9].name);
+ EXPECT_EQ("11", lists[9].adds);
+ EXPECT_TRUE(lists[9].subs.empty());
database_.reset();
}
@@ -484,7 +503,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
&SafeBrowsingDatabase::ContainsBrowseUrl },
{ safe_browsing_util::kPhishingList, 1U,
&SafeBrowsingDatabase::ContainsBrowseUrl },
- { safe_browsing_util::kUnwantedUrlList, 8U,
+ { safe_browsing_util::kUnwantedUrlList, 9U,
&SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl },
};
@@ -1098,7 +1117,7 @@ TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
base::MessageLoop loop;
SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile();
database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL, NULL, NULL,
- NULL, NULL, NULL));
+ NULL, NULL, NULL, NULL));
database_->Init(database_filename_);
// This will cause an empty database to be created.
@@ -1241,182 +1260,261 @@ TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrl) {
// Checks that the whitelists are handled properly.
TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
+ struct TestCase {
+ using TestListContainsWhitelistedUrl =
+ bool (SafeBrowsingDatabase::*)(const GURL& url);
+ using TestListContainsWhitelistedString =
+ bool (SafeBrowsingDatabase::*)(const std::string& str);
+
+ // Returns true if strings should be tested in this test case (i.e.
+ // |test_list_contains_whitelisted_string| is not null).
+ bool TestStrings() const {
+ return test_list_contains_whitelisted_string != nullptr;
+ }
+
+ const char* test_list_name;
+ TestListContainsWhitelistedUrl test_list_contains_whitelisted_url;
+ // Optional test case field, if set the tested whitelist will also be tested
+ // for strings.
+ TestListContainsWhitelistedString test_list_contains_whitelisted_string;
+ } const kTestCases[]{
+ {safe_browsing_util::kCsdWhiteList,
+ &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl,
+ nullptr},
+ {safe_browsing_util::kDownloadWhiteList,
+ &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl,
+ &SafeBrowsingDatabase::ContainsDownloadWhitelistedString},
+ {safe_browsing_util::kInclusionWhitelist,
+ &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl,
+ nullptr},
+ };
+
// If the whitelist is disabled everything should match the whitelist.
- database_.reset(new SafeBrowsingDatabaseNew(new SafeBrowsingStoreFile(),
+ database_.reset(new SafeBrowsingDatabaseNew(new SafeBrowsingStoreFile(), NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL));
database_->Init(database_filename_);
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.phishing.com/"))));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.phishing.com/"))));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf"));
+ for (const auto& test_case : kTestCases) {
+ SCOPED_TRACE(std::string("Tested list at fault => ") +
+ test_case.test_list_name);
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.phishing.com/"))));
+ if (test_case.TestStrings()) {
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ "asdf"));
+ }
+ }
ResetAndReloadFullDatabase();
- const char kGood1Host[] = "www.good1.com/";
- const char kGood1Url1[] = "www.good1.com/a/b.html";
- const char kGood1Url2[] = "www.good1.com/b/";
-
- const char kGood2Url1[] = "www.good2.com/c"; // Should match '/c/bla'.
-
- // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist.
- const char kGood3Url1[] = "good3.com/";
-
- const char kGoodString[] = "good_string";
-
- ScopedVector<SBChunkData> csd_chunks;
- ScopedVector<SBChunkData> download_chunks;
-
- // Add two simple chunks to the csd whitelist.
- csd_chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2));
- csd_chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
- download_chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
- download_chunks.push_back(AddChunkFullHashValue(3, kGoodString));
- download_chunks.push_back(AddChunkFullHashValue(4, kGood3Url1));
-
- std::vector<SBListChunkRanges> lists;
- ASSERT_TRUE(database_->UpdateStarted(&lists));
- database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get());
- database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
- download_chunks.get());
- database_->UpdateFinished(true);
-
- EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood1Host)));
-
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood1Url1)));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood1Url1 + "?a=b")));
-
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood1Url2)));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood1Url2 + "/c.html")));
+ // Now test every whitelist one-by-one; intentionally not resetting the
+ // database in-between to further stress potential inter-dependencies.
+ for (const auto& test_case : kTestCases) {
+ SCOPED_TRACE(std::string("Tested list at fault => ") +
+ test_case.test_list_name);
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+ const char kGood1Host[] = "www.good1.com/";
+ const char kGood1Url1[] = "www.good1.com/a/b.html";
+ const char kGood1Url2[] = "www.good1.com/b/";
+
+ const char kGood2Url1[] = "www.good2.com/c"; // Should match '/c/bla'.
+
+ // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist.
+ const char kGood3Url1[] = "good3.com/";
+
+ const char kGoodString[] = "good_string";
+
+ // Nothing should be whitelisted before the database receives the chunks.
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Host)));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url1)));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url2)));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood2Url1)));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood3Url1)));
+ if (test_case.TestStrings()) {
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ kGoodString));
+ }
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c")));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
+ ScopedVector<SBChunkData> chunks;
- EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
+ // Add a few test chunks to the whitelist under test.
+ chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2));
+ chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
+ if (test_case.TestStrings())
+ chunks.push_back(AddChunkFullHashValue(3, kGoodString));
+ chunks.push_back(AddChunkFullHashValue(4, kGood3Url1));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c")));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
+ std::vector<SBListChunkRanges> lists;
+ ASSERT_TRUE(database_->UpdateStarted(&lists));
+ database_->InsertChunks(test_case.test_list_name, chunks.get());
+ database_->UpdateFinished(true);
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://good3.com/a/b/c/d/e/f/g/"))));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://a.b.good3.com/"))));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Host)));
+
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url1)));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url1 + "?a=b")));
+
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url2)));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood1Url2 + "/c.html")));
+
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood2Url1 + "/c")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
+
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.google.com/"))));
+
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://") + kGood3Url1 + "a/b/c/d/e/f/g/")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://a.b.") + kGood3Url1)));
+
+ if (test_case.TestStrings()) {
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ "asdf"));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ kGoodString));
+ }
- EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf"));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.google.com/"))));
- EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
+ // The malware kill switch is for the CSD whitelist only.
+ if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+ // The CSD whitelist killswitch is not present.
+ EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
- // The CSD whitelist killswitch is not present.
- EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
+ // Test only add the malware IP killswitch
+ chunks.clear();
+ chunks.push_back(AddChunkFullHashValue(
+ 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware"));
- // Test only add the malware IP killswitch
- csd_chunks.clear();
- csd_chunks.push_back(AddChunkFullHashValue(
- 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware"));
+ ASSERT_TRUE(database_->UpdateStarted(&lists));
+ database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get());
+ database_->UpdateFinished(true);
- ASSERT_TRUE(database_->UpdateStarted(&lists));
- database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get());
- database_->UpdateFinished(true);
+ EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
+ // The CSD whitelist killswitch is not present.
+ EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
+ }
- EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
- // The CSD whitelist killswitch is not present.
- EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
+ // Test that the generic whitelist kill-switch works as intended.
+ chunks.clear();
+ lists.clear();
+ chunks.push_back(AddChunkFullHashValue(
+ 5, "sb-ssl.google.com/safebrowsing/csd/killswitch"));
- // Test that the kill-switch works as intended.
- csd_chunks.clear();
- download_chunks.clear();
- lists.clear();
- csd_chunks.push_back(AddChunkFullHashValue(
- 5, "sb-ssl.google.com/safebrowsing/csd/killswitch"));
- download_chunks.push_back(AddChunkFullHashValue(
- 5, "sb-ssl.google.com/safebrowsing/csd/killswitch"));
+ ASSERT_TRUE(database_->UpdateStarted(&lists));
+ database_->InsertChunks(test_case.test_list_name, chunks.get());
+ database_->UpdateFinished(true);
- ASSERT_TRUE(database_->UpdateStarted(&lists));
- database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get());
- database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
- download_chunks.get());
- database_->UpdateFinished(true);
+ // Test CSD whitelist specific methods.
+ if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+ // The CSD whitelist killswitch is present.
+ EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn());
+ EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
+ }
- // The CSD whitelist killswitch is present.
- EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn());
- EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("https://") + kGood1Url2 + "/c.html")));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://www.phishing_url.com/"))));
-
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("https://") + kGood1Url2 + "/c.html")));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.phishing_url.com/"))));
-
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf"));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
-
- // Remove the kill-switch and verify that we can recover.
- csd_chunks.clear();
- download_chunks.clear();
- lists.clear();
- csd_chunks.push_back(SubChunkFullHashValue(
- 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
- csd_chunks.push_back(SubChunkFullHashValue(
- 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15));
- download_chunks.push_back(SubChunkFullHashValue(
- 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.google.com/"))));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.phishing_url.com/"))));
+
+ if (test_case.TestStrings()) {
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ "asdf"));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ kGoodString));
+ }
- ASSERT_TRUE(database_->UpdateStarted(&lists));
- database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get());
- database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
- download_chunks.get());
- database_->UpdateFinished(true);
+ // Remove the kill-switch and verify that we can recover.
+ chunks.clear();
+ lists.clear();
+ chunks.push_back(SubChunkFullHashValue(
+ 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
+ if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+ chunks.push_back(SubChunkFullHashValue(
+ 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15));
+ }
- EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
- EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("https://") + kGood1Url2 + "/c.html")));
- EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
- EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
- EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
- GURL(std::string("http://www.phishing_url.com/"))));
-
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("https://good3.com/"))));
- EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
- EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.google.com/"))));
- EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
- GURL(std::string("http://www.phishing_url.com/"))));
- EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf"));
+ ASSERT_TRUE(database_->UpdateStarted(&lists));
+ database_->InsertChunks(test_case.test_list_name, chunks.get());
+ database_->UpdateFinished(true);
- database_.reset();
+ if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+ EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
+ EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
+ }
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("https://") + kGood3Url1)));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.google.com/"))));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+ GURL(std::string("http://www.phishing_url.com/"))));
+ if (test_case.TestStrings()) {
+ EXPECT_TRUE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ kGoodString));
+ EXPECT_FALSE(
+ (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+ "asdf"));
+ }
+ }
}
// Test to make sure we could insert chunk list that
« no previous file with comments | « chrome/browser/safe_browsing/safe_browsing_database.cc ('k') | chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698