tld_cleanup_util_unittest.cc 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/tools/tld_cleanup/tld_cleanup_util.h"
  5. #include "base/files/file_path.h"
  6. #include "testing/gtest/include/gtest/gtest.h"
  7. namespace net::tld_cleanup {
  8. std::string SetupData(const std::string& icann_domains,
  9. const std::string& private_domains) {
  10. return "// ===BEGIN ICANN DOMAINS===\n" +
  11. icann_domains +
  12. "// ===END ICANN DOMAINS===\n" +
  13. "// ===BEGIN PRIVATE DOMAINS===\n" +
  14. private_domains +
  15. "// ===END PRIVATE DOMAINS===\n";
  16. }
  17. TEST(TldCleanupUtilTest, TwoRealTldsSuccessfullyRead) {
  18. std::string icann_domains = "foo\n"
  19. "bar\n";
  20. std::string private_domains = "";
  21. std::string data = SetupData(icann_domains, private_domains);
  22. RuleMap rules;
  23. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  24. ASSERT_EQ(kSuccess, result);
  25. ASSERT_EQ(2U, rules.size());
  26. RuleMap::const_iterator foo_iter = rules.find("foo");
  27. ASSERT_FALSE(rules.end() == foo_iter);
  28. EXPECT_FALSE(foo_iter->second.wildcard);
  29. EXPECT_FALSE(foo_iter->second.exception);
  30. EXPECT_FALSE(foo_iter->second.is_private);
  31. RuleMap::const_iterator bar_iter = rules.find("bar");
  32. ASSERT_FALSE(rules.end() == bar_iter);
  33. EXPECT_FALSE(bar_iter->second.wildcard);
  34. EXPECT_FALSE(bar_iter->second.exception);
  35. EXPECT_FALSE(bar_iter->second.is_private);
  36. }
  37. TEST(TldCleanupUtilTest, RealTldAutomaticallyAddedForSubdomain) {
  38. std::string icann_domains = "foo.bar\n";
  39. std::string private_domains = "";
  40. std::string data = SetupData(icann_domains, private_domains);
  41. RuleMap rules;
  42. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  43. ASSERT_EQ(kSuccess, result);
  44. ASSERT_EQ(2U, rules.size());
  45. RuleMap::const_iterator foo_bar_iter = rules.find("foo.bar");
  46. ASSERT_FALSE(rules.end() == foo_bar_iter);
  47. EXPECT_FALSE(foo_bar_iter->second.wildcard);
  48. EXPECT_FALSE(foo_bar_iter->second.exception);
  49. EXPECT_FALSE(foo_bar_iter->second.is_private);
  50. RuleMap::const_iterator bar_iter = rules.find("bar");
  51. ASSERT_FALSE(rules.end() == bar_iter);
  52. EXPECT_FALSE(bar_iter->second.wildcard);
  53. EXPECT_FALSE(bar_iter->second.exception);
  54. EXPECT_FALSE(bar_iter->second.is_private);
  55. }
  56. TEST(TldCleanupUtilTest, PrivateTldMarkedAsPrivate) {
  57. std::string icann_domains = "foo\n"
  58. "bar\n";
  59. std::string private_domains = "baz\n";
  60. std::string data = SetupData(icann_domains, private_domains);
  61. RuleMap rules;
  62. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  63. ASSERT_EQ(kSuccess, result);
  64. ASSERT_EQ(3U, rules.size());
  65. RuleMap::const_iterator foo_iter = rules.find("foo");
  66. ASSERT_FALSE(rules.end() == foo_iter);
  67. EXPECT_FALSE(foo_iter->second.wildcard);
  68. EXPECT_FALSE(foo_iter->second.exception);
  69. EXPECT_FALSE(foo_iter->second.is_private);
  70. RuleMap::const_iterator bar_iter = rules.find("bar");
  71. ASSERT_FALSE(rules.end() == bar_iter);
  72. EXPECT_FALSE(bar_iter->second.wildcard);
  73. EXPECT_FALSE(bar_iter->second.exception);
  74. EXPECT_FALSE(bar_iter->second.is_private);
  75. RuleMap::const_iterator baz_iter = rules.find("baz");
  76. ASSERT_FALSE(rules.end() == baz_iter);
  77. EXPECT_FALSE(baz_iter->second.wildcard);
  78. EXPECT_FALSE(baz_iter->second.exception);
  79. EXPECT_TRUE(baz_iter->second.is_private);
  80. }
  81. TEST(TldCleanupUtilTest, PrivateDomainMarkedAsPrivate) {
  82. std::string icann_domains = "bar\n";
  83. std::string private_domains = "foo.bar\n";
  84. std::string data = SetupData(icann_domains, private_domains);
  85. RuleMap rules;
  86. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  87. ASSERT_EQ(kSuccess, result);
  88. ASSERT_EQ(2U, rules.size());
  89. RuleMap::const_iterator bar_iter = rules.find("bar");
  90. ASSERT_FALSE(rules.end() == bar_iter);
  91. EXPECT_FALSE(bar_iter->second.wildcard);
  92. EXPECT_FALSE(bar_iter->second.exception);
  93. EXPECT_FALSE(bar_iter->second.is_private);
  94. RuleMap::const_iterator foo_bar_iter = rules.find("foo.bar");
  95. ASSERT_FALSE(rules.end() == foo_bar_iter);
  96. EXPECT_FALSE(foo_bar_iter->second.wildcard);
  97. EXPECT_FALSE(foo_bar_iter->second.exception);
  98. EXPECT_TRUE(foo_bar_iter->second.is_private);
  99. }
  100. TEST(TldCleanupUtilTest, ExtraTldRuleIsNotMarkedPrivate) {
  101. std::string icann_domains = "foo.bar\n"
  102. "baz.bar\n";
  103. std::string private_domains = "qux.bar\n";
  104. std::string data = SetupData(icann_domains, private_domains);
  105. RuleMap rules;
  106. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  107. ASSERT_EQ(kSuccess, result);
  108. ASSERT_EQ(4U, rules.size());
  109. RuleMap::const_iterator foo_bar_iter = rules.find("foo.bar");
  110. ASSERT_FALSE(rules.end() == foo_bar_iter);
  111. EXPECT_FALSE(foo_bar_iter->second.wildcard);
  112. EXPECT_FALSE(foo_bar_iter->second.exception);
  113. EXPECT_FALSE(foo_bar_iter->second.is_private);
  114. RuleMap::const_iterator baz_bar_iter = rules.find("baz.bar");
  115. ASSERT_FALSE(rules.end() == baz_bar_iter);
  116. EXPECT_FALSE(baz_bar_iter->second.wildcard);
  117. EXPECT_FALSE(baz_bar_iter->second.exception);
  118. EXPECT_FALSE(baz_bar_iter->second.is_private);
  119. RuleMap::const_iterator bar_iter = rules.find("bar");
  120. ASSERT_FALSE(rules.end() == bar_iter);
  121. EXPECT_FALSE(bar_iter->second.wildcard);
  122. EXPECT_FALSE(bar_iter->second.exception);
  123. EXPECT_FALSE(bar_iter->second.is_private);
  124. RuleMap::const_iterator qux_bar_iter = rules.find("qux.bar");
  125. ASSERT_FALSE(rules.end() == qux_bar_iter);
  126. EXPECT_FALSE(qux_bar_iter->second.wildcard);
  127. EXPECT_FALSE(qux_bar_iter->second.exception);
  128. EXPECT_TRUE(qux_bar_iter->second.is_private);
  129. }
  130. TEST(TldCleanupUtilTest, WildcardAndExceptionParsedCorrectly) {
  131. std::string icann_domains = "*.bar\n"
  132. "!foo.bar\n";
  133. std::string private_domains = "!baz.bar\n";
  134. std::string data = SetupData(icann_domains, private_domains);
  135. RuleMap rules;
  136. NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
  137. ASSERT_EQ(kSuccess, result);
  138. ASSERT_EQ(3U, rules.size());
  139. RuleMap::const_iterator foo_bar_iter = rules.find("bar");
  140. ASSERT_FALSE(rules.end() == foo_bar_iter);
  141. EXPECT_TRUE(foo_bar_iter->second.wildcard);
  142. EXPECT_FALSE(foo_bar_iter->second.exception);
  143. EXPECT_FALSE(foo_bar_iter->second.is_private);
  144. RuleMap::const_iterator bar_iter = rules.find("foo.bar");
  145. ASSERT_FALSE(rules.end() == bar_iter);
  146. EXPECT_FALSE(bar_iter->second.wildcard);
  147. EXPECT_TRUE(bar_iter->second.exception);
  148. EXPECT_FALSE(bar_iter->second.is_private);
  149. RuleMap::const_iterator baz_bar_iter = rules.find("baz.bar");
  150. ASSERT_FALSE(rules.end() == baz_bar_iter);
  151. EXPECT_FALSE(baz_bar_iter->second.wildcard);
  152. EXPECT_TRUE(baz_bar_iter->second.exception);
  153. EXPECT_TRUE(baz_bar_iter->second.is_private);
  154. }
  155. } // namespace net::tld_cleanup