blob: 80e569b5cfb6f8fcf21a80709bf9486465abef34 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright 2020 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.
#ifndef CONTENT_BROWSER_CONVERSIONS_CONVERSION_TEST_UTILS_H_
#define CONTENT_BROWSER_CONVERSIONS_CONVERSION_TEST_UTILS_H_
#include <list>
#include <string>
#include <vector>
#include "base/memory/scoped_refptr.h"
#include "base/sequenced_task_runner.h"
#include "base/time/time.h"
#include "content/browser/conversions/conversion_manager.h"
#include "content/browser/conversions/conversion_manager_impl.h"
#include "content/browser/conversions/conversion_report.h"
#include "content/browser/conversions/conversion_storage.h"
#include "content/browser/conversions/storable_conversion.h"
#include "content/browser/conversions/storable_impression.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "url/origin.h"
namespace content {
class ConfigurableStorageDelegate : public ConversionStorage::Delegate {
public:
using AttributionCredits = std::list<int>;
ConfigurableStorageDelegate();
~ConfigurableStorageDelegate() override;
// ConversionStorage::Delegate
void ProcessNewConversionReports(
std::vector<ConversionReport>* reports) override;
int GetMaxConversionsPerImpression() const override;
int GetMaxImpressionsPerOrigin() const override;
int GetMaxConversionsPerOrigin() const override;
void set_max_conversions_per_impression(int max) {
max_conversions_per_impression_ = max;
}
void set_max_impressions_per_origin(int max) {
max_impressions_per_origin_ = max;
}
void set_max_conversions_per_origin(int max) {
max_conversions_per_origin_ = max;
}
void set_report_time_ms(int report_time_ms) {
report_time_ms_ = report_time_ms;
}
void AddCredits(AttributionCredits credits) {
// Add all credits to our list in order.
attribution_credits_.splice(attribution_credits_.end(), credits);
}
private:
int max_conversions_per_impression_ = INT_MAX;
int max_impressions_per_origin_ = INT_MAX;
int max_conversions_per_origin_ = INT_MAX;
int report_time_ms_ = 0;
// List of attribution credits the test delegate should associate with
// reports.
AttributionCredits attribution_credits_;
};
// Test manager provider which can be used to inject a fake ConversionManager.
class TestManagerProvider : public ConversionManager::Provider {
public:
explicit TestManagerProvider(ConversionManager* manager)
: manager_(manager) {}
~TestManagerProvider() override = default;
ConversionManager* GetManager(WebContents* web_contents) const override;
private:
ConversionManager* manager_ = nullptr;
};
// Test ConversionManager which can be injected into tests to monitor calls to a
// ConversionManager instance.
class TestConversionManager : public ConversionManager {
public:
TestConversionManager();
~TestConversionManager() override;
// ConversionManager:
void HandleImpression(const StorableImpression& impression) override;
void HandleConversion(const StorableConversion& conversion) override;
void GetActiveImpressionsForWebUI(
base::OnceCallback<void(std::vector<StorableImpression>)> callback)
override;
void GetReportsForWebUI(
base::OnceCallback<void(std::vector<ConversionReport>)> callback,
base::Time max_report_time) override;
void SendReportsForWebUI(base::OnceClosure done) override;
const ConversionPolicy& GetConversionPolicy() const override;
void ClearData(base::Time delete_begin,
base::Time delete_end,
base::RepeatingCallback<bool(const url::Origin&)> filter,
base::OnceClosure done) override;
void SetActiveImpressionsForWebUI(
std::vector<StorableImpression> impressions);
void SetReportsForWebUI(std::vector<ConversionReport> reports);
// Resets all counters on this.
void Reset();
size_t num_impressions() const { return num_impressions_; }
size_t num_conversions() const { return num_conversions_; }
private:
ConversionPolicy policy_;
size_t num_impressions_ = 0;
size_t num_conversions_ = 0;
std::vector<StorableImpression> impressions_;
std::vector<ConversionReport> reports_;
};
// Helper class to construct a StorableImpression for tests using default data.
// StorableImpression members are not mutable after construction requiring a
// builder pattern.
class ImpressionBuilder {
public:
explicit ImpressionBuilder(base::Time time);
~ImpressionBuilder();
ImpressionBuilder& SetExpiry(base::TimeDelta delta);
ImpressionBuilder& SetData(const std::string& data);
ImpressionBuilder& SetImpressionOrigin(const url::Origin& origin);
ImpressionBuilder& SetConversionOrigin(const url::Origin& origin);
ImpressionBuilder& SetReportingOrigin(const url::Origin& origin);
StorableImpression Build() const;
private:
std::string impression_data_;
base::Time impression_time_;
base::TimeDelta expiry_;
url::Origin impression_origin_;
url::Origin conversion_origin_;
url::Origin reporting_origin_;
};
// Returns a StorableConversion with default data which matches the default
// impressions created by ImpressionBuilder.
StorableConversion DefaultConversion();
testing::AssertionResult ImpressionsEqual(const StorableImpression& expected,
const StorableImpression& actual);
testing::AssertionResult ReportsEqual(
const std::vector<ConversionReport>& expected,
const std::vector<ConversionReport>& actual);
std::vector<ConversionReport> GetConversionsToReportForTesting(
ConversionManagerImpl* manager,
base::Time max_report_time);
} // namespace content
#endif // CONTENT_BROWSER_CONVERSIONS_CONVERSION_TEST_UTILS_H_
|
