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
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/feedback/feedback_data.h"
#include <memory>
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "components/feedback/feedback_report.h"
#include "components/feedback/feedback_uploader.h"
#include "components/prefs/testing_pref_service.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
#include "services/network/test/test_url_loader_factory.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace feedback {
namespace {
constexpr char kHistograms[] = "Histogram Data";
constexpr char kImageData[] = "Image Data";
constexpr char kFileData[] = "File Data";
constexpr char kAutofillMetadata[] = "Autofill Metadata";
class MockUploader : public FeedbackUploader {
public:
MockUploader(
bool is_off_the_record,
const base::FilePath& state_path,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
base::OnceClosure on_report_sent)
: FeedbackUploader(is_off_the_record, state_path, url_loader_factory),
on_report_sent_(std::move(on_report_sent)) {}
MockUploader(const MockUploader&) = delete;
MockUploader& operator=(const MockUploader&) = delete;
// feedback::FeedbackUploader:
void StartDispatchingReport() override { std::move(on_report_sent_).Run(); }
base::WeakPtr<FeedbackUploader> AsWeakPtr() override {
return weak_ptr_factory_.GetWeakPtr();
}
void QueueReport(std::unique_ptr<std::string> data,
bool has_email,
int product_id) override {
report_had_email_ = has_email;
called_queue_report_ = true;
FeedbackUploader::QueueReport(std::move(data), has_email, product_id);
}
bool called_queue_report() const { return called_queue_report_; }
bool report_had_email() const { return report_had_email_; }
private:
base::OnceClosure on_report_sent_;
bool called_queue_report_ = false;
bool report_had_email_ = false;
base::WeakPtrFactory<MockUploader> weak_ptr_factory_{this};
};
} // namespace
class FeedbackDataTest : public testing::Test {
protected:
FeedbackDataTest()
: test_shared_loader_factory_(
base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
&test_url_loader_factory_)) {
EXPECT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
uploader_ = std::make_unique<MockUploader>(
/*is_off_the_record=*/false, scoped_temp_dir_.GetPath(),
test_shared_loader_factory_,
base::BindOnce(&FeedbackDataTest::set_send_report_callback,
base::Unretained(this)));
data_ = base::MakeRefCounted<FeedbackData>(uploader_->AsWeakPtr(), nullptr);
}
void Send() {
bool attached_file_completed = data_->attached_file_uuid().empty();
bool screenshot_completed = data_->screenshot_uuid().empty();
if (screenshot_completed && attached_file_completed) {
data_->OnFeedbackPageDataComplete();
}
}
void RunMessageLoop() {
run_loop_ = std::make_unique<base::RunLoop>();
quit_closure_ = run_loop_->QuitClosure();
Send();
run_loop_->Run();
}
void set_send_report_callback() { std::move(quit_closure_).Run(); }
base::test::TaskEnvironment task_environment_{
base::test::TaskEnvironment::TimeSource::MOCK_TIME};
base::OnceClosure quit_closure_;
std::unique_ptr<base::RunLoop> run_loop_;
base::ScopedTempDir scoped_temp_dir_;
network::TestURLLoaderFactory test_url_loader_factory_;
scoped_refptr<network::SharedURLLoaderFactory> test_shared_loader_factory_;
std::unique_ptr<MockUploader> uploader_;
scoped_refptr<FeedbackData> data_;
};
TEST_F(FeedbackDataTest, ReportSending) {
data_->SetAndCompressHistograms(kHistograms);
data_->set_autofill_metadata(kAutofillMetadata);
data_->CompressAutofillMetadata();
data_->set_image(kImageData);
data_->AttachAndCompressFileData(kFileData);
RunMessageLoop();
EXPECT_EQ(data_->user_email(), "");
EXPECT_TRUE(data_->IsDataComplete());
EXPECT_TRUE(uploader_->called_queue_report());
EXPECT_FALSE(uploader_->report_had_email());
}
TEST_F(FeedbackDataTest, ReportSendingWithEmail) {
data_->SetAndCompressHistograms(kHistograms);
data_->set_autofill_metadata(kAutofillMetadata);
data_->CompressAutofillMetadata();
data_->set_image(kImageData);
data_->AttachAndCompressFileData(kFileData);
data_->set_user_email("foo@bar.com");
RunMessageLoop();
EXPECT_EQ(data_->user_email(), "foo@bar.com");
EXPECT_TRUE(data_->IsDataComplete());
EXPECT_TRUE(uploader_->called_queue_report());
EXPECT_TRUE(uploader_->report_had_email());
}
TEST_F(FeedbackDataTest, ReportSendingAutofillMetadata) {
data_->set_autofill_metadata(kAutofillMetadata);
data_->CompressAutofillMetadata();
RunMessageLoop();
EXPECT_EQ(data_->user_email(), "");
EXPECT_TRUE(data_->IsDataComplete());
EXPECT_TRUE(uploader_->called_queue_report());
EXPECT_FALSE(uploader_->report_had_email());
ASSERT_EQ(data_->attachments(), 1UL);
EXPECT_EQ(data_->attachment(0)->name, "autofill_metadata.zip");
}
} // namespace feedback
|
