| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 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 | |
| 5 #include "remoting/signaling/telemetry_log_writer.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/macros.h" | |
| 10 #include "base/memory/ptr_util.h" | |
| 11 #include "net/http/http_status_code.h" | |
| 12 #include "remoting/base/url_request.h" | |
| 13 #include "remoting/signaling/chromoting_event.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 | |
| 16 namespace remoting { | |
| 17 | |
| 18 class FakeUrlRequest : public UrlRequest { | |
| 19 public: | |
| 20 FakeUrlRequest(const std::string& expected_post, | |
| 21 const UrlRequest::Result& returned_result) | |
| 22 : expected_post_(expected_post), returned_result_(returned_result) {} | |
| 23 | |
| 24 void Respond() { on_result_callback_.Run(returned_result_); } | |
| 25 | |
| 26 // UrlRequest overrides. | |
| 27 void SetPostData(const std::string& content_type, | |
| 28 const std::string& post_data) override { | |
| 29 EXPECT_EQ(content_type, "application/json"); | |
| 30 EXPECT_EQ(post_data, expected_post_); | |
| 31 } | |
| 32 | |
| 33 void AddHeader(const std::string& value) override {} | |
| 34 | |
| 35 void Start(const OnResultCallback& on_result_callback) override { | |
| 36 on_result_callback_ = on_result_callback; | |
| 37 } | |
| 38 | |
| 39 private: | |
| 40 std::string expected_post_; | |
| 41 UrlRequest::Result returned_result_; | |
| 42 OnResultCallback on_result_callback_; | |
| 43 | |
| 44 DISALLOW_COPY_AND_ASSIGN(FakeUrlRequest); | |
| 45 }; | |
| 46 | |
| 47 class FakeUrlRequestFactory : public UrlRequestFactory { | |
| 48 public: | |
| 49 ~FakeUrlRequestFactory() override { EXPECT_TRUE(expected_requests_.empty()); } | |
| 50 | |
| 51 // Returns a respond closure. Run this closure to respond to the URL request. | |
| 52 base::Closure AddExpectedRequest(const std::string& exp_post, | |
| 53 const UrlRequest::Result& ret_result) { | |
| 54 FakeUrlRequest* fakeRequest = new FakeUrlRequest(exp_post, ret_result); | |
| 55 base::Closure closure = | |
| 56 base::Bind(&FakeUrlRequest::Respond, base::Unretained(fakeRequest)); | |
| 57 expected_requests_.push_back(std::unique_ptr<UrlRequest>(fakeRequest)); | |
| 58 return closure; | |
| 59 } | |
| 60 | |
| 61 // request_factory_ override. | |
| 62 std::unique_ptr<UrlRequest> CreateUrlRequest( | |
| 63 UrlRequest::Type type, | |
| 64 const std::string& url) override { | |
| 65 EXPECT_FALSE(expected_requests_.empty()); | |
| 66 if (expected_requests_.empty()) { | |
| 67 return std::unique_ptr<UrlRequest>(nullptr); | |
| 68 } | |
| 69 EXPECT_EQ(type, UrlRequest::Type::POST); | |
| 70 std::unique_ptr<UrlRequest> request(std::move(expected_requests_.front())); | |
| 71 expected_requests_.pop_front(); | |
| 72 return request; | |
| 73 } | |
| 74 | |
| 75 private: | |
| 76 std::deque<std::unique_ptr<UrlRequest>> expected_requests_; | |
| 77 }; | |
| 78 | |
| 79 class TelemetryLogWriterTest : public testing::Test { | |
| 80 public: | |
| 81 TelemetryLogWriterTest() | |
| 82 : request_factory_(new FakeUrlRequestFactory()), | |
| 83 log_writer_("", base::WrapUnique(request_factory_)) { | |
| 84 success_result_.success = true; | |
| 85 success_result_.status = 200; | |
| 86 success_result_.response_body = "{}"; | |
| 87 | |
| 88 unauth_result_.success = false; | |
| 89 unauth_result_.status = net::HTTP_UNAUTHORIZED; | |
| 90 unauth_result_.response_body = "{}"; | |
| 91 } | |
| 92 | |
| 93 protected: | |
| 94 void LogFakeEvent() { | |
| 95 ChromotingEvent entry; | |
| 96 entry.SetInteger("id", id_); | |
| 97 id_++; | |
| 98 log_writer_.Log(entry); | |
| 99 } | |
| 100 | |
| 101 void SetAuthClosure() { | |
| 102 log_writer_.SetAuthClosure( | |
| 103 base::Bind(&TelemetryLogWriterTest::SetAuth, base::Unretained(this))); | |
| 104 } | |
| 105 | |
| 106 UrlRequest::Result success_result_; | |
| 107 UrlRequest::Result unauth_result_; | |
| 108 | |
| 109 FakeUrlRequestFactory* request_factory_; // For peeking. No ownership. | |
| 110 TelemetryLogWriter log_writer_; | |
| 111 | |
| 112 int set_auth_count_ = 0; | |
| 113 | |
| 114 private: | |
| 115 void SetAuth() { | |
| 116 set_auth_count_++; | |
| 117 log_writer_.SetAuthToken("some token"); | |
| 118 } | |
| 119 | |
| 120 int id_ = 0; | |
| 121 }; | |
| 122 | |
| 123 // Test workflow: add request -> log event -> respond request. | |
| 124 // Test fails if req is incorrect or creates more/less reqs than expected | |
| 125 TEST_F(TelemetryLogWriterTest, PostOneLogImmediately) { | |
| 126 auto respond = request_factory_->AddExpectedRequest( | |
| 127 "{\"event\":[{\"id\":0}]}", success_result_); | |
| 128 LogFakeEvent(); | |
| 129 respond.Run(); | |
| 130 } | |
| 131 | |
| 132 TEST_F(TelemetryLogWriterTest, PostOneLogAndHaveTwoPendingLogs) { | |
| 133 auto respond1 = request_factory_->AddExpectedRequest( | |
| 134 "{\"event\":[{\"id\":0}]}", success_result_); | |
| 135 LogFakeEvent(); | |
| 136 | |
| 137 auto respond2 = request_factory_->AddExpectedRequest( | |
| 138 "{\"event\":[{\"id\":1},{\"id\":2}]}", success_result_); | |
| 139 LogFakeEvent(); | |
| 140 LogFakeEvent(); | |
| 141 respond1.Run(); | |
| 142 respond2.Run(); | |
| 143 } | |
| 144 | |
| 145 TEST_F(TelemetryLogWriterTest, PostLogFailedAndRetry) { | |
| 146 // kMaxTries = 5 | |
| 147 auto respond1 = request_factory_->AddExpectedRequest( | |
| 148 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 149 auto respond2 = request_factory_->AddExpectedRequest( | |
| 150 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 151 auto respond3 = request_factory_->AddExpectedRequest( | |
| 152 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 153 auto respond4 = request_factory_->AddExpectedRequest( | |
| 154 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 155 auto respond5 = request_factory_->AddExpectedRequest( | |
| 156 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 157 | |
| 158 LogFakeEvent(); | |
| 159 | |
| 160 respond1.Run(); | |
| 161 respond2.Run(); | |
| 162 respond3.Run(); | |
| 163 respond4.Run(); | |
| 164 respond5.Run(); | |
| 165 } | |
| 166 | |
| 167 TEST_F(TelemetryLogWriterTest, PostOneLogFailedResendWithTwoPendingLogs) { | |
| 168 auto respond1 = request_factory_->AddExpectedRequest( | |
| 169 "{\"event\":[{\"id\":0}]}", UrlRequest::Result::Failed()); | |
| 170 LogFakeEvent(); | |
| 171 | |
| 172 auto respond2 = request_factory_->AddExpectedRequest( | |
| 173 "{\"event\":[{\"id\":1},{\"id\":2},{\"id\":0}]}", success_result_); | |
| 174 LogFakeEvent(); | |
| 175 LogFakeEvent(); | |
| 176 | |
| 177 respond1.Run(); | |
| 178 respond2.Run(); | |
| 179 } | |
| 180 | |
| 181 TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedCallClosureAndRetry) { | |
| 182 SetAuthClosure(); | |
| 183 | |
| 184 auto respond1 = request_factory_->AddExpectedRequest( | |
| 185 "{\"event\":[{\"id\":0}]}", unauth_result_); | |
| 186 LogFakeEvent(); | |
| 187 | |
| 188 auto respond2 = request_factory_->AddExpectedRequest( | |
| 189 "{\"event\":[{\"id\":0}]}", success_result_); | |
| 190 respond1.Run(); | |
| 191 respond2.Run(); | |
| 192 | |
| 193 EXPECT_EQ(1, set_auth_count_); | |
| 194 } | |
| 195 | |
| 196 TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedAndJustRetry) { | |
| 197 auto respond1 = request_factory_->AddExpectedRequest( | |
| 198 "{\"event\":[{\"id\":0}]}", unauth_result_); | |
| 199 LogFakeEvent(); | |
| 200 | |
| 201 auto respond2 = request_factory_->AddExpectedRequest( | |
| 202 "{\"event\":[{\"id\":0}]}", success_result_); | |
| 203 respond1.Run(); | |
| 204 respond2.Run(); | |
| 205 | |
| 206 EXPECT_EQ(0, set_auth_count_); | |
| 207 } | |
| 208 | |
| 209 } // namespace remoting | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1972793002:
TelemetryLogWriter cleanups (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master