[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / cc990d1014c1b32aba943d0c5bb47fe4469d40fc / . / content / browser / aggregation_service / aggregatable_report_assembler_unittest.cc
blob: 23ec4c5b06d5b8d4f53367a9c5dad95ee4c312aa [file] [log] [blame]
Avi Drissman4e1b7bc2022-09-15 14:03:50[diff] [blame]1// Copyright 2021 The Chromium Authors
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/aggregation_service/aggregatable_report_assembler.h"
6
7#include <stddef.h>
8
9#include <memory>
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]10#include <optional>
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]11#include <utility>
12#include <vector>
13
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]14#include "base/memory/raw_ptr.h"
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]15#include "base/test/gmock_callback_support.h"
16#include "base/test/gmock_move_support.h"
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]17#include "base/test/metrics/histogram_tester.h"
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]18#include "base/test/mock_callback.h"
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]19#include "content/browser/aggregation_service/aggregatable_report.h"
20#include "content/browser/aggregation_service/aggregation_service_key_fetcher.h"
21#include "content/browser/aggregation_service/aggregation_service_test_utils.h"
22#include "content/browser/aggregation_service/public_key.h"
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]23#include "testing/gmock/include/gmock/gmock.h"
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]24#include "testing/gtest/include/gtest/gtest.h"
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]25#include "third_party/blink/public/mojom/private_aggregation/aggregatable_report.mojom.h"
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]26#include "url/gurl.h"
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]27
28namespace content {
29
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]30namespace {
31
32using ::testing::_;
33using ::testing::Eq;
34using ::testing::Invoke;
35using ::testing::Return;
36
37// Will be used to verify the sequence of expected function calls.
38using Checkpoint = ::testing::MockFunction<void(int)>;
39
40using FetchCallback = AggregationServiceKeyFetcher::FetchCallback;
41using AssemblyCallback = AggregatableReportAssembler::AssemblyCallback;
42using PublicKeyFetchStatus = AggregationServiceKeyFetcher::PublicKeyFetchStatus;
43using AssemblyStatus = AggregatableReportAssembler::AssemblyStatus;
44
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]45constexpr char kReportAssemblerStatusHistogramName[] =
46 "PrivacySandbox.AggregationService.ReportAssembler.Status";
47
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]48auto CloneRequestAndReturnReport(std::optional<AggregatableReportRequest>* out,
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]49 AggregatableReport report) {
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]50 return [out, report = std::move(report)](
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]51 const AggregatableReportRequest& report_request,
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]52 std::vector<PublicKey> public_keys) {
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]53 *out = aggregation_service::CloneReportRequest(report_request);
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]54 return std::move(report);
55 };
56}
57
58class MockAggregationServiceKeyFetcher : public AggregationServiceKeyFetcher {
59 public:
60 MockAggregationServiceKeyFetcher()
61 : AggregationServiceKeyFetcher(/*storage_context=*/nullptr,
62 /*network_fetcher=*/nullptr) {}
63
64 MOCK_METHOD(void,
65 GetPublicKey,
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]66 (const GURL& url, FetchCallback callback),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]67 (override));
68};
69
70class MockAggregatableReportProvider : public AggregatableReport::Provider {
71 public:
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]72 MOCK_METHOD(std::optional<AggregatableReport>,
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]73 CreateFromRequestAndPublicKeys,
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]74 (const AggregatableReportRequest&, std::vector<PublicKey>),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]75 (const, override));
76};
77
78} // namespace
79
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]80class AggregatableReportAssemblerTest : public testing::Test {
81 public:
82 AggregatableReportAssemblerTest() = default;
83
84 void SetUp() override {
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]85 auto fetcher = std::make_unique<MockAggregationServiceKeyFetcher>();
86 auto report_provider = std::make_unique<MockAggregatableReportProvider>();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]87
88 fetcher_ = fetcher.get();
89 report_provider_ = report_provider.get();
90 assembler_ = AggregatableReportAssembler::CreateForTesting(
91 std::move(fetcher), std::move(report_provider));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]92 }
93
Tom Sepez239d7ff2023-03-10 22:18:05[diff] [blame]94 void ResetAssembler() {
95 fetcher_ = nullptr;
96 report_provider_ = nullptr;
97 assembler_.reset();
98 }
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]99
100 AggregatableReportAssembler* assembler() { return assembler_.get(); }
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]101 MockAggregationServiceKeyFetcher* fetcher() { return fetcher_; }
102 MockAggregatableReportProvider* report_provider() { return report_provider_; }
103 base::MockCallback<AssemblyCallback>& callback() { return callback_; }
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]104
105 private:
106 std::unique_ptr<AggregatableReportAssembler> assembler_;
107
108 // These objects are owned by `assembler_`.
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]109 raw_ptr<MockAggregationServiceKeyFetcher> fetcher_;
110 raw_ptr<MockAggregatableReportProvider> report_provider_;
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]111
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]112 base::MockCallback<AssemblyCallback> callback_;
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]113};
114
115TEST_F(AggregatableReportAssemblerTest, BothKeyFetchesFail_ErrorReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]116 base::HistogramTester histograms;
117
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]118 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]119 blink::mojom::AggregationServiceMode::kExperimentalPoplar);
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]120 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]121
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]122 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]123 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]124 std::nullopt, PublicKeyFetchStatus::kPublicKeyFetchFailed));
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]125 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[1], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]126 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]127 std::nullopt, PublicKeyFetchStatus::kPublicKeyFetchFailed));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]128 EXPECT_CALL(callback(),
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]129 Run(_, Eq(std::nullopt), AssemblyStatus::kPublicKeyFetchFailed));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]130
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]131 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(_, _))
132 .Times(0);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]133
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]134 assembler()->AssembleReport(std::move(request), callback().Get());
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]135
136 histograms.ExpectUniqueSample(
137 kReportAssemblerStatusHistogramName,
138 AggregatableReportAssembler::AssemblyStatus::kPublicKeyFetchFailed, 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]139}
140
141TEST_F(AggregatableReportAssemblerTest, FirstKeyFetchFails_ErrorReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]142 base::HistogramTester histograms;
143
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]144 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]145 blink::mojom::AggregationServiceMode::kExperimentalPoplar);
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]146 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]147
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]148 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]149 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]150 std::nullopt, PublicKeyFetchStatus::kPublicKeyFetchFailed));
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]151 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[1], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]152 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]153 aggregation_service::TestHpkeKey().GetPublicKey(),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]154 PublicKeyFetchStatus::kOk));
155 EXPECT_CALL(callback(),
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]156 Run(_, Eq(std::nullopt), AssemblyStatus::kPublicKeyFetchFailed));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]157
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]158 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(_, _))
159 .Times(0);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]160
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]161 assembler()->AssembleReport(std::move(request), callback().Get());
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]162
163 histograms.ExpectUniqueSample(
164 kReportAssemblerStatusHistogramName,
165 AggregatableReportAssembler::AssemblyStatus::kPublicKeyFetchFailed, 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]166}
167
168TEST_F(AggregatableReportAssemblerTest, SecondKeyFetchFails_ErrorReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]169 base::HistogramTester histograms;
170
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]171 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]172 blink::mojom::AggregationServiceMode::kExperimentalPoplar);
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]173 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]174
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]175 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]176 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]177 aggregation_service::TestHpkeKey().GetPublicKey(),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]178 PublicKeyFetchStatus::kOk));
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]179 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[1], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]180 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]181 std::nullopt, PublicKeyFetchStatus::kPublicKeyFetchFailed));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]182 EXPECT_CALL(callback(),
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]183 Run(_, Eq(std::nullopt), AssemblyStatus::kPublicKeyFetchFailed));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]184
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]185 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(_, _))
186 .Times(0);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]187
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]188 assembler()->AssembleReport(std::move(request), callback().Get());
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]189
190 histograms.ExpectUniqueSample(
191 kReportAssemblerStatusHistogramName,
192 AggregatableReportAssembler::AssemblyStatus::kPublicKeyFetchFailed, 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]193}
194
195TEST_F(AggregatableReportAssemblerTest,
196 BothKeyFetchesSucceed_ValidReportReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]197 base::HistogramTester histograms;
198
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]199 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]200 blink::mojom::AggregationServiceMode::kExperimentalPoplar);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]201
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]202 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]203 std::vector<PublicKey> public_keys = {
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]204 aggregation_service::TestHpkeKey("id123").GetPublicKey(),
205 aggregation_service::TestHpkeKey("456abc").GetPublicKey()};
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]206
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]207 std::optional<AggregatableReport> report =
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]208 AggregatableReport::Provider().CreateFromRequestAndPublicKeys(
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]209 request, public_keys);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]210 ASSERT_TRUE(report.has_value());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]211
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]212 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]213 .WillOnce(base::test::RunOnceCallback<1>(public_keys[0],
214 PublicKeyFetchStatus::kOk));
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]215 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[1], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]216 .WillOnce(base::test::RunOnceCallback<1>(public_keys[1],
217 PublicKeyFetchStatus::kOk));
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]218 EXPECT_CALL(callback(), Run(_, report, AssemblyStatus::kOk));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]219
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]220 std::optional<AggregatableReportRequest> actual_request;
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]221 EXPECT_CALL(*report_provider(),
222 CreateFromRequestAndPublicKeys(_, public_keys))
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]223 .WillOnce(CloneRequestAndReturnReport(&actual_request,
224 std::move(report.value())));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]225
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]226 assembler()->AssembleReport(aggregation_service::CloneReportRequest(request),
227 callback().Get());
228 ASSERT_TRUE(actual_request.has_value());
229 EXPECT_TRUE(aggregation_service::ReportRequestsEqual(actual_request.value(),
230 request));
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]231
232 histograms.ExpectUniqueSample(
233 kReportAssemblerStatusHistogramName,
234 AggregatableReportAssembler::AssemblyStatus::kOk, 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]235}
236
237TEST_F(AggregatableReportAssemblerTest,
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]238 OnlyKeyFetchSucceeds_ValidReportReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]239 base::HistogramTester histograms;
240
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]241 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]242 blink::mojom::AggregationServiceMode::kTeeBased);
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]243
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]244 PublicKey public_key =
245 aggregation_service::TestHpkeKey("id123").GetPublicKey();
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]246
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]247 std::optional<AggregatableReport> report =
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]248 AggregatableReport::Provider().CreateFromRequestAndPublicKeys(
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]249 request, {public_key});
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]250 ASSERT_TRUE(report.has_value());
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]251
Nan Linf1a880f82022-02-10 17:59:08[diff] [blame]252 EXPECT_CALL(*fetcher(), GetPublicKey)
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]253 .WillOnce(base::test::RunOnceCallback<1>(public_key,
254 PublicKeyFetchStatus::kOk));
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]255 EXPECT_CALL(callback(), Run(_, report, AssemblyStatus::kOk));
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]256
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]257 std::optional<AggregatableReportRequest> actual_request;
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]258 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(
259 _, std::vector<PublicKey>{public_key}))
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]260 .WillOnce(CloneRequestAndReturnReport(&actual_request,
261 std::move(report.value())));
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]262
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]263 assembler()->AssembleReport(aggregation_service::CloneReportRequest(request),
264 callback().Get());
265 ASSERT_TRUE(actual_request.has_value());
266 EXPECT_TRUE(aggregation_service::ReportRequestsEqual(actual_request.value(),
267 request));
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]268
269 histograms.ExpectUniqueSample(
270 kReportAssemblerStatusHistogramName,
271 AggregatableReportAssembler::AssemblyStatus::kOk, 1);
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]272}
273
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]274TEST_F(AggregatableReportAssemblerTest, OnlyKeyFetchFails_ErrorReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]275 base::HistogramTester histograms;
276
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]277 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]278 blink::mojom::AggregationServiceMode::kTeeBased);
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]279
Nan Linf1a880f82022-02-10 17:59:08[diff] [blame]280 EXPECT_CALL(*fetcher(), GetPublicKey)
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]281 .WillOnce(base::test::RunOnceCallback<1>(
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]282 std::nullopt, PublicKeyFetchStatus::kPublicKeyFetchFailed));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]283 EXPECT_CALL(callback(),
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]284 Run(_, Eq(std::nullopt), AssemblyStatus::kPublicKeyFetchFailed));
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]285
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]286 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(_, _))
287 .Times(0);
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]288
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]289 assembler()->AssembleReport(std::move(request), callback().Get());
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]290
291 histograms.ExpectUniqueSample(
292 kReportAssemblerStatusHistogramName,
293 AggregatableReportAssembler::AssemblyStatus::kPublicKeyFetchFailed, 1);
Alex Turner68655bec2021-11-03 16:20:53[diff] [blame]294}
295
296TEST_F(AggregatableReportAssemblerTest,
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]297 TwoKeyFetchesReturnInSwappedOrder_ValidReportReturned) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]298 base::HistogramTester histograms;
299
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]300 AggregatableReportRequest request = aggregation_service::CreateExampleRequest(
Yao Xiao4890a292023-02-28 23:52:47[diff] [blame]301 blink::mojom::AggregationServiceMode::kExperimentalPoplar);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]302
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]303 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]304 std::vector<PublicKey> public_keys = {
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]305 aggregation_service::TestHpkeKey("id123").GetPublicKey(),
306 aggregation_service::TestHpkeKey("456abc").GetPublicKey()};
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]307
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]308 std::optional<AggregatableReport> report =
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]309 AggregatableReport::Provider().CreateFromRequestAndPublicKeys(
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]310 request, public_keys);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]311 ASSERT_TRUE(report.has_value());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]312
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]313 std::vector<FetchCallback> pending_callbacks(2);
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]314 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]315 .WillOnce(MoveArg<1>(&pending_callbacks.front()));
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]316 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[1], _))
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]317 .WillOnce(MoveArg<1>(&pending_callbacks.back()));
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]318 EXPECT_CALL(callback(), Run(_, report, AssemblyStatus::kOk));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]319
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]320 std::optional<AggregatableReportRequest> actual_request;
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]321 EXPECT_CALL(*report_provider(),
322 CreateFromRequestAndPublicKeys(_, public_keys))
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]323 .WillOnce(CloneRequestAndReturnReport(&actual_request,
324 std::move(report.value())));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]325
326 assembler()->AssembleReport(aggregation_service::CloneReportRequest(request),
327 callback().Get());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]328
329 // Swap order of responses
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]330 std::move(pending_callbacks.back())
331 .Run(public_keys[1], PublicKeyFetchStatus::kOk);
332 std::move(pending_callbacks.front())
333 .Run(public_keys[0], PublicKeyFetchStatus::kOk);
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]334
335 histograms.ExpectUniqueSample(
336 kReportAssemblerStatusHistogramName,
337 AggregatableReportAssembler::AssemblyStatus::kOk, 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]338}
339
340TEST_F(AggregatableReportAssemblerTest,
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]341 AssemblerDeleted_PendingRequestsNotRun) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]342 base::HistogramTester histograms;
343
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]344 AggregatableReportRequest request =
345 aggregation_service::CreateExampleRequest();
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]346 std::vector<GURL> processing_urls = request.processing_urls();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]347
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]348 EXPECT_CALL(callback(), Run).Times(0);
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]349 EXPECT_CALL(*fetcher(), GetPublicKey);
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]350 assembler()->AssembleReport(std::move(request), callback().Get());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]351
352 ResetAssembler();
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]353
354 histograms.ExpectTotalCount(kReportAssemblerStatusHistogramName, 0);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]355}
356
357TEST_F(AggregatableReportAssemblerTest,
358 MultipleSimultaneousRequests_BothSucceed) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]359 base::HistogramTester histograms;
360
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]361 AggregatableReportRequest request =
362 aggregation_service::CreateExampleRequest();
363
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]364 std::vector<GURL> processing_urls = request.processing_urls();
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]365 PublicKey public_key =
366 aggregation_service::TestHpkeKey("id123").GetPublicKey();
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]367
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]368 std::optional<AggregatableReport> report =
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]369 AggregatableReport::Provider().CreateFromRequestAndPublicKeys(
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]370 request, {public_key});
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]371 ASSERT_TRUE(report.has_value());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]372
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]373 std::vector<FetchCallback> pending_callbacks(2);
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]374 EXPECT_CALL(*fetcher(), GetPublicKey(processing_urls[0], _))
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]375 .WillOnce(MoveArg<1>(&pending_callbacks.front()))
376 .WillOnce(MoveArg<1>(&pending_callbacks.back()));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]377
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]378 EXPECT_CALL(callback(), Run(_, report, AssemblyStatus::kOk)).Times(2);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]379
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]380 std::optional<AggregatableReportRequest> first_request;
381 std::optional<AggregatableReportRequest> second_request;
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]382 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys(
383 _, std::vector<PublicKey>{public_key}))
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]384 .WillOnce(CloneRequestAndReturnReport(&first_request, report.value()))
385 .WillOnce(CloneRequestAndReturnReport(&second_request,
386 std::move(report.value())));
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]387
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]388 assembler()->AssembleReport(aggregation_service::CloneReportRequest(request),
389 callback().Get());
390 assembler()->AssembleReport(aggregation_service::CloneReportRequest(request),
391 callback().Get());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]392
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]393 std::move(pending_callbacks.front())
394 .Run(public_key, PublicKeyFetchStatus::kOk);
395 std::move(pending_callbacks.back())
396 .Run(public_key, PublicKeyFetchStatus::kOk);
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]397
398 ASSERT_TRUE(first_request.has_value());
399 EXPECT_TRUE(
400 aggregation_service::ReportRequestsEqual(first_request.value(), request));
401 ASSERT_TRUE(second_request.has_value());
402 EXPECT_TRUE(aggregation_service::ReportRequestsEqual(second_request.value(),
403 request));
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]404
405 histograms.ExpectUniqueSample(
406 kReportAssemblerStatusHistogramName,
407 AggregatableReportAssembler::AssemblyStatus::kOk, 2);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]408}
409
410TEST_F(AggregatableReportAssemblerTest,
411 TooManySimultaneousRequests_ErrorCausedForNewRequests) {
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]412 base::HistogramTester histograms;
413
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]414 PublicKey public_key =
415 aggregation_service::TestHpkeKey("id123").GetPublicKey();
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]416 std::optional<AggregatableReport> report =
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]417 AggregatableReport::Provider().CreateFromRequestAndPublicKeys(
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]418 aggregation_service::CreateExampleRequest(), {std::move(public_key)});
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]419 ASSERT_TRUE(report.has_value());
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]420
421 std::vector<FetchCallback> pending_callbacks;
422
423 Checkpoint checkpoint;
424 int current_call = 1;
425
426 {
427 testing::InSequence seq;
428 int current_check = 1;
429
430 EXPECT_CALL(*fetcher(), GetPublicKey)
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]431 .Times(AggregatableReportAssembler::kMaxSimultaneousRequests)
Nan Lin4c75cd82022-02-18 23:39:34[diff] [blame]432 .WillRepeatedly(Invoke([&](const GURL& url, FetchCallback callback) {
433 pending_callbacks.push_back(std::move(callback));
434 }));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]435
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]436 EXPECT_CALL(callback(), Run).Times(0);
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]437
438 EXPECT_CALL(checkpoint, Call(current_check++));
439
Dan McArdle08ad6112023-11-21 20:39:47[diff] [blame]440 EXPECT_CALL(callback(), Run(_, Eq(std::nullopt),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]441 AssemblyStatus::kTooManySimultaneousRequests))
442 .Times(1);
443
444 EXPECT_CALL(checkpoint, Call(current_check++));
445
446 for (size_t i = 0;
447 i < AggregatableReportAssembler::kMaxSimultaneousRequests; i++) {
448 EXPECT_CALL(checkpoint, Call(current_check++));
449 EXPECT_CALL(*report_provider(), CreateFromRequestAndPublicKeys)
450 .WillOnce(Return(report));
Nan Lin55ad2a5a2022-08-15 21:32:57[diff] [blame]451 EXPECT_CALL(callback(), Run(_, report, AssemblyStatus::kOk));
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]452 }
453 }
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]454
455 for (size_t i = 0; i < AggregatableReportAssembler::kMaxSimultaneousRequests;
456 ++i) {
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]457 assembler()->AssembleReport(aggregation_service::CreateExampleRequest(),
458 callback().Get());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]459 }
460
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]461 checkpoint.Call(current_call++);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]462
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]463 assembler()->AssembleReport(aggregation_service::CreateExampleRequest(),
464 callback().Get());
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]465
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]466 checkpoint.Call(current_call++);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]467
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]468 for (FetchCallback& pending_callback : pending_callbacks) {
469 checkpoint.Call(current_call++);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]470
Alex Turnerbed5a1942022-03-14 22:38:06[diff] [blame]471 std::move(pending_callback)
Dan McArdle1bb24d42023-10-24 22:29:13[diff] [blame]472 .Run(aggregation_service::TestHpkeKey("id123").GetPublicKey(),
Nan Lin32c794f2022-01-25 22:57:03[diff] [blame]473 PublicKeyFetchStatus::kOk);
474 }
Nan Lind637a9c92022-02-24 02:48:02[diff] [blame]475
476 histograms.ExpectBucketCount(
477 kReportAssemblerStatusHistogramName,
478 AggregatableReportAssembler::AssemblyStatus::kOk,
479 AggregatableReportAssembler::kMaxSimultaneousRequests);
480 histograms.ExpectBucketCount(
481 kReportAssemblerStatusHistogramName,
482 AggregatableReportAssembler::AssemblyStatus::kTooManySimultaneousRequests,
483 1);
Alex Turner7b0c6b62021-10-05 18:34:39[diff] [blame]484}
485
486} // namespace content