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
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/browser/api/feedback_private/feedback_private_api_unittest_base_chromeos.h"
#include <memory>
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/task/single_thread_task_runner.h"
#include "components/feedback/system_logs/system_logs_source.h"
#include "components/keyed_service/core/keyed_service.h"
#include "extensions/browser/api/api_resource_manager.h"
#include "extensions/browser/api/feedback_private/log_source_access_manager.h"
#include "extensions/browser/api/feedback_private/log_source_resource.h"
#include "extensions/common/api/feedback_private.h"
#include "extensions/shell/browser/api/feedback_private/shell_feedback_private_delegate.h"
#include "extensions/shell/browser/shell_extensions_api_client.h"
namespace extensions {
namespace {
using api::feedback_private::LogSource;
using system_logs::SystemLogsResponse;
using system_logs::SystemLogsSource;
// A fake MAC address used to test redaction.
const char kDummyMacAddress[] = "11:22:33:44:55:66";
std::unique_ptr<KeyedService> ApiResourceManagerTestFactory(
content::BrowserContext* context) {
return std::make_unique<ApiResourceManager<LogSourceResource>>(context);
}
// A dummy SystemLogsSource that does not require real system logs to be
// available during testing.
class TestSingleLogSource : public SystemLogsSource {
public:
explicit TestSingleLogSource(LogSource type)
: SystemLogsSource(ToString(type)) {}
TestSingleLogSource(const TestSingleLogSource&) = delete;
TestSingleLogSource& operator=(const TestSingleLogSource&) = delete;
~TestSingleLogSource() override = default;
// Fetch() will return a single different string each time, in the following
// sequence: "a", " bb", " ccc", until 25 spaces followed by 26 z's. After
// that, it returns |kDummyMacAddress| before repeating the entire process.
// It will never return an empty result.
void Fetch(system_logs::SysLogsSourceCallback callback) override {
std::string result = GetNextLogResult();
DCHECK_GT(result.size(), 0U);
auto result_map = std::make_unique<SystemLogsResponse>();
result_map->emplace("", result);
// Do not directly pass the result to the callback, because that's not how
// log sources actually work. Instead, simulate the asynchronous operation
// of a SystemLogsSource by invoking the callback separately.
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), std::move(result_map)));
}
private:
std::string GetNextLogResult() {
if (call_count_ == kNumCharsToIterate) {
call_count_ = 0;
return kDummyMacAddress;
}
std::string result =
std::string(call_count_, ' ') +
std::string(call_count_ + 1, kInitialChar + call_count_);
++call_count_;
return result;
}
// Iterate over the whole lowercase alphabet, starting from 'a'.
const int kNumCharsToIterate = 26;
const char kInitialChar = 'a';
// Keep track of how many times Fetch() has been called, in order to determine
// its behavior each time.
int call_count_ = 0;
};
class TestFeedbackPrivateDelegate : public ShellFeedbackPrivateDelegate {
public:
TestFeedbackPrivateDelegate() = default;
TestFeedbackPrivateDelegate(const TestFeedbackPrivateDelegate&) = delete;
TestFeedbackPrivateDelegate& operator=(const TestFeedbackPrivateDelegate&) =
delete;
~TestFeedbackPrivateDelegate() override = default;
std::unique_ptr<system_logs::SystemLogsSource> CreateSingleLogSource(
api::feedback_private::LogSource source_type) const override {
return std::make_unique<TestSingleLogSource>(source_type);
}
};
class TestExtensionsAPIClient : public ShellExtensionsAPIClient {
public:
TestExtensionsAPIClient() = default;
TestExtensionsAPIClient(const TestExtensionsAPIClient&) = delete;
TestExtensionsAPIClient& operator=(const TestExtensionsAPIClient&) = delete;
~TestExtensionsAPIClient() override = default;
// ShellExtensionsApiClient implementation:
FeedbackPrivateDelegate* GetFeedbackPrivateDelegate() override {
if (!feedback_private_delegate_) {
feedback_private_delegate_ =
std::make_unique<TestFeedbackPrivateDelegate>();
}
return feedback_private_delegate_.get();
}
private:
std::unique_ptr<FeedbackPrivateDelegate> feedback_private_delegate_;
};
} // namespace
FeedbackPrivateApiUnittestBase::FeedbackPrivateApiUnittestBase() = default;
FeedbackPrivateApiUnittestBase::~FeedbackPrivateApiUnittestBase() = default;
void FeedbackPrivateApiUnittestBase::SetUp() {
extensions_api_client_ = std::make_unique<TestExtensionsAPIClient>();
ApiUnitTest::SetUp();
// The ApiResourceManager used for LogSourceResource is destroyed every time
// a unit test finishes, during TearDown(). There is no way to re-create it
// normally. The below code forces it to be re-created during SetUp(), so
// that there is always a valid ApiResourceManager<LogSourceResource> when
// subsequent unit tests are running.
ApiResourceManager<LogSourceResource>::GetFactoryInstance()
->SetTestingFactoryAndUse(
browser_context(),
base::BindRepeating(&ApiResourceManagerTestFactory));
}
void FeedbackPrivateApiUnittestBase::TearDown() {
// Clear the rate limit override that tests may have set.
LogSourceAccessManager::SetRateLimitingTimeoutForTesting(nullptr);
ApiUnitTest::TearDown();
}
} // namespace extensions
|
