url_param_filter_test_helper.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278
  1. // Copyright 2022 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 "components/url_param_filter/core/url_param_filter_test_helper.h"
  5. #include "base/base64.h"
  6. #include "components/url_param_filter/core/url_param_classifications_loader.h"
  7. #include "components/url_param_filter/core/url_param_filterer.h"
  8. #include "third_party/zlib/google/compression_utils.h"
  9. namespace url_param_filter {
  10. namespace {
  11. constexpr char DEFAULT_TAG[] = "default";
  12. std::map<std::string,
  13. std::map<FilterClassification::UseCase, std::vector<std::string>>>
  14. ConvertToDefaultUseCases(
  15. const std::map<std::string, std::vector<std::string>>& source) {
  16. std::map<std::string,
  17. std::map<FilterClassification::UseCase, std::vector<std::string>>>
  18. source_with_use_cases;
  19. for (auto i : source) {
  20. source_with_use_cases[i.first][FilterClassification::USE_CASE_UNKNOWN] =
  21. i.second;
  22. }
  23. return source_with_use_cases;
  24. }
  25. } // namespace
  26. // Create a ClassificationMap with the default non-experimental status.
  27. ClassificationMap CreateClassificationMapForTesting(
  28. const std::map<std::string,
  29. std::map<FilterClassification::UseCase,
  30. std::vector<std::string>>>& source,
  31. FilterClassification_SiteRole role) {
  32. url_param_filter::ClassificationMap result;
  33. for (auto i : source) {
  34. for (auto j : i.second) {
  35. for (auto k : j.second) {
  36. result[{.site_role = role, .site = i.first}][j.first][k] =
  37. ClassificationExperimentStatus::NON_EXPERIMENTAL;
  38. }
  39. }
  40. }
  41. return result;
  42. }
  43. url_param_filter::ClassificationMap CreateClassificationMapForTesting(
  44. const std::map<ClassificationMapKey, std::vector<std::string>>& source) {
  45. url_param_filter::ClassificationMap result;
  46. for (const auto& [key, params] : source) {
  47. for (const auto& param : params) {
  48. result[key][FilterClassification::USE_CASE_UNKNOWN][param] =
  49. ClassificationExperimentStatus::NON_EXPERIMENTAL;
  50. }
  51. }
  52. return result;
  53. }
  54. std::string CreateSerializedUrlParamFilterClassificationForTesting(
  55. const std::map<std::string,
  56. std::map<FilterClassification::UseCase,
  57. std::vector<std::string>>>& source_params,
  58. const std::map<std::string,
  59. std::map<FilterClassification::UseCase,
  60. std::vector<std::string>>>& destination_params,
  61. const std::vector<std::string>& experiment_tags) {
  62. url_param_filter::FilterClassifications classifications;
  63. for (auto [key, inner_map] : CreateClassificationMapForTesting(
  64. source_params, url_param_filter::FilterClassification_SiteRole::
  65. FilterClassification_SiteRole_SOURCE)) {
  66. for (auto j : inner_map) {
  67. url_param_filter::FilterClassification classification;
  68. classification.set_site(key.site);
  69. for (auto i : experiment_tags) {
  70. classification.add_experiment_tags(i);
  71. }
  72. classification.set_site_role(
  73. url_param_filter::FilterClassification::SOURCE);
  74. if (j.first != FilterClassification::USE_CASE_UNKNOWN) {
  75. classification.add_use_cases(j.first);
  76. }
  77. for (auto k : j.second) {
  78. url_param_filter::FilterParameter* parameter =
  79. classification.add_parameters();
  80. parameter->set_name(k.first);
  81. }
  82. *classifications.add_classifications() = std::move(classification);
  83. }
  84. }
  85. for (auto [key, inner_map] : CreateClassificationMapForTesting(
  86. destination_params, url_param_filter::FilterClassification_SiteRole::
  87. FilterClassification_SiteRole_DESTINATION)) {
  88. for (auto j : inner_map) {
  89. url_param_filter::FilterClassification classification;
  90. classification.set_site(key.site);
  91. for (auto i : experiment_tags) {
  92. classification.add_experiment_tags(i);
  93. }
  94. classification.set_site_role(
  95. url_param_filter::FilterClassification::DESTINATION);
  96. if (j.first != FilterClassification::USE_CASE_UNKNOWN) {
  97. classification.add_use_cases(j.first);
  98. }
  99. for (auto k : j.second) {
  100. url_param_filter::FilterParameter* parameter =
  101. classification.add_parameters();
  102. parameter->set_name(k.first);
  103. }
  104. *classifications.add_classifications() = std::move(classification);
  105. }
  106. }
  107. return classifications.SerializeAsString();
  108. }
  109. std::string CreateSerializedUrlParamFilterClassificationForTesting(
  110. const std::map<std::string, std::vector<std::string>>& source_params,
  111. const std::map<std::string, std::vector<std::string>>& destination_params,
  112. const std::vector<std::string>& experiment_tags) {
  113. return CreateSerializedUrlParamFilterClassificationForTesting(
  114. ConvertToDefaultUseCases(source_params),
  115. ConvertToDefaultUseCases(destination_params), experiment_tags);
  116. }
  117. std::string CreateBase64EncodedFilterParamClassificationForTesting(
  118. const std::map<std::string,
  119. std::map<FilterClassification::UseCase,
  120. std::vector<std::string>>>& source_params,
  121. const std::map<std::string,
  122. std::map<FilterClassification::UseCase,
  123. std::vector<std::string>>>& destination_params) {
  124. std::string compressed;
  125. compression::GzipCompress(
  126. CreateSerializedUrlParamFilterClassificationForTesting(
  127. source_params, destination_params, {}),
  128. &compressed);
  129. std::string out;
  130. base::Base64Encode(compressed, &out);
  131. return out;
  132. }
  133. std::string CreateBase64EncodedFilterParamClassificationForTesting(
  134. const std::map<std::string, std::vector<std::string>>& source_params,
  135. const std::map<std::string, std::vector<std::string>>& destination_params) {
  136. std::string compressed;
  137. compression::GzipCompress(
  138. CreateSerializedUrlParamFilterClassificationForTesting(
  139. source_params, destination_params, {}),
  140. &compressed);
  141. std::string out;
  142. base::Base64Encode(compressed, &out);
  143. return out;
  144. }
  145. FilterClassifications MakeClassificationsProtoFromMapWithUseCases(
  146. const std::map<std::string,
  147. std::map<FilterClassification::UseCase,
  148. std::vector<std::string>>>& source_map,
  149. const std::map<std::string,
  150. std::map<FilterClassification::UseCase,
  151. std::vector<std::string>>>& dest_map) {
  152. url_param_filter::FilterClassifications classifications;
  153. for (const auto& [site, param_map] : source_map) {
  154. for (const auto& [use_case, params] : param_map) {
  155. AddClassification(classifications.add_classifications(), site,
  156. FilterClassification_SiteRole_SOURCE,
  157. FilterClassification_SiteMatchType_EXACT_ETLD_PLUS_ONE,
  158. params, {use_case}, {DEFAULT_TAG});
  159. }
  160. }
  161. for (const auto& [site, param_map] : dest_map) {
  162. for (const auto& [use_case, params] : param_map) {
  163. AddClassification(classifications.add_classifications(), site,
  164. FilterClassification_SiteRole_DESTINATION,
  165. FilterClassification_SiteMatchType_EXACT_ETLD_PLUS_ONE,
  166. params, {use_case}, {DEFAULT_TAG});
  167. }
  168. }
  169. return classifications;
  170. }
  171. FilterClassifications MakeClassificationsProtoFromMap(
  172. const std::map<ClassificationMapKey, std::vector<std::string>>& map) {
  173. url_param_filter::FilterClassifications classifications;
  174. for (const auto& [key, params] : map) {
  175. AddClassification(classifications.add_classifications(), key.site,
  176. key.site_role, key.site_match_type, params,
  177. {
  178. FilterClassification::USE_CASE_UNKNOWN,
  179. },
  180. {DEFAULT_TAG});
  181. }
  182. return classifications;
  183. }
  184. FilterClassifications MakeClassificationsProtoFromMap(
  185. const std::map<std::string, std::vector<std::string>>& source_map,
  186. const std::map<std::string, std::vector<std::string>>& dest_map) {
  187. url_param_filter::FilterClassifications classifications;
  188. std::vector<FilterClassification::UseCase> use_cases;
  189. for (const auto& [site, params] : source_map) {
  190. AddClassification(classifications.add_classifications(), site,
  191. FilterClassification_SiteRole_SOURCE,
  192. FilterClassification_SiteMatchType_EXACT_ETLD_PLUS_ONE,
  193. params, use_cases, {});
  194. }
  195. for (const auto& [site, params] : dest_map) {
  196. AddClassification(classifications.add_classifications(), site,
  197. FilterClassification_SiteRole_DESTINATION,
  198. FilterClassification_SiteMatchType_EXACT_ETLD_PLUS_ONE,
  199. params, use_cases, {});
  200. }
  201. return classifications;
  202. }
  203. FilterClassification MakeFilterClassification(
  204. const std::string& site,
  205. FilterClassification_SiteRole role,
  206. FilterClassification_SiteMatchType site_match_type,
  207. const std::vector<std::string>& params) {
  208. return MakeFilterClassification(site, role, site_match_type, params, {},
  209. DEFAULT_TAG);
  210. }
  211. FilterClassification MakeFilterClassification(
  212. const std::string& site,
  213. FilterClassification_SiteRole role,
  214. FilterClassification_SiteMatchType site_match_type,
  215. const std::vector<std::string>& params,
  216. const std::vector<FilterClassification::UseCase>& use_cases) {
  217. return MakeFilterClassification(site, role, site_match_type, params,
  218. use_cases, DEFAULT_TAG);
  219. }
  220. FilterClassification MakeFilterClassification(
  221. const std::string& site,
  222. FilterClassification_SiteRole role,
  223. FilterClassification_SiteMatchType site_match_type,
  224. const std::vector<std::string>& params,
  225. const std::vector<FilterClassification::UseCase>& use_cases,
  226. const std::string& experiment_identifier) {
  227. FilterClassification fc;
  228. AddClassification(&fc, site, role, site_match_type, params, use_cases,
  229. {experiment_identifier});
  230. return fc;
  231. }
  232. void AddClassification(
  233. FilterClassification* classification,
  234. const std::string& site,
  235. FilterClassification_SiteRole role,
  236. FilterClassification_SiteMatchType site_match_type,
  237. const std::vector<std::string>& params,
  238. const std::vector<FilterClassification::UseCase>& use_cases,
  239. const std::vector<std::string>& experiment_tags) {
  240. classification->set_site(site);
  241. classification->set_site_role(role);
  242. classification->set_site_match_type(site_match_type);
  243. // The proto distinguishes between empty and not set; for the purposes of this
  244. // test helper, we avoid empty being considered an experiment.
  245. if (!experiment_tags.empty()) {
  246. for (auto i : experiment_tags) {
  247. classification->add_experiment_tags(i);
  248. }
  249. } else {
  250. classification->add_experiment_tags(DEFAULT_TAG);
  251. }
  252. for (const FilterClassification::UseCase& use_case : use_cases) {
  253. classification->add_use_cases(use_case);
  254. }
  255. for (const std::string& param : params) {
  256. FilterParameter* parameters = classification->add_parameters();
  257. parameters->set_name(param);
  258. }
  259. }
  260. } // namespace url_param_filter