OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 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 "mojo/shell/shell_test_base.h" |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/i18n/time_formatting.h" |
| 9 #include "base/macros.h" |
| 10 #include "base/message_loop/message_loop.h" |
| 11 #include "base/strings/utf_string_conversions.h" |
| 12 #include "mojo/public/cpp/bindings/error_handler.h" |
| 13 #include "mojo/public/cpp/bindings/interface_ptr.h" |
| 14 #include "mojo/public/cpp/system/core.h" |
| 15 #include "mojo/services/test_service/test_request_tracker.mojom.h" |
| 16 #include "mojo/services/test_service/test_service.mojom.h" |
| 17 #include "testing/gtest/include/gtest/gtest.h" |
| 18 #include "url/gurl.h" |
| 19 |
| 20 using mojo::test::ServiceReport; |
| 21 using mojo::test::ServiceReportPtr; |
| 22 using mojo::test::TestService; |
| 23 using mojo::test::TestTimeService; |
| 24 using mojo::test::TestServicePtr; |
| 25 using mojo::test::TestTimeServicePtr; |
| 26 using mojo::test::TestTrackedRequestService; |
| 27 using mojo::test::TestTrackedRequestServicePtr; |
| 28 |
| 29 namespace mojo { |
| 30 namespace shell { |
| 31 namespace test { |
| 32 namespace { |
| 33 |
| 34 void GetReportCallback(base::MessageLoop* loop, |
| 35 std::vector<ServiceReport>* reports_out, |
| 36 Array<ServiceReportPtr> report) { |
| 37 for (size_t i = 0; i < report.size(); i++) |
| 38 reports_out->push_back(*report[i]); |
| 39 loop->QuitWhenIdle(); |
| 40 } |
| 41 |
| 42 class ShellTestBaseTest : public ShellTestBase { |
| 43 public: |
| 44 // Convenience helpers for use as callbacks in tests. |
| 45 template <typename T> |
| 46 base::Callback<void()> SetAndQuit(T* val, T result) { |
| 47 return base::Bind(&ShellTestBaseTest::SetAndQuitImpl<T>, |
| 48 base::Unretained(this), val, result); |
| 49 } |
| 50 template <typename T> |
| 51 base::Callback<void(T result)> SetAndQuit(T* val) { |
| 52 return base::Bind(&ShellTestBaseTest::SetAndQuitImpl<T>, |
| 53 base::Unretained(this), val); |
| 54 } |
| 55 static GURL test_app_url() { return GURL("mojo:test_app"); } |
| 56 |
| 57 void GetReport(std::vector<ServiceReport>* report) { |
| 58 ConnectToService(GURL("mojo:test_request_tracker_app"), &request_tracking_); |
| 59 request_tracking_->GetReport(base::Bind(&GetReportCallback, |
| 60 base::Unretained(message_loop()), |
| 61 base::Unretained(report))); |
| 62 message_loop()->Run(); |
| 63 } |
| 64 |
| 65 private: |
| 66 template <typename T> |
| 67 void SetAndQuitImpl(T* val, T result) { |
| 68 *val = result; |
| 69 message_loop()->QuitWhenIdle(); |
| 70 } |
| 71 TestTrackedRequestServicePtr request_tracking_; |
| 72 }; |
| 73 |
| 74 class QuitMessageLoopErrorHandler : public ErrorHandler { |
| 75 public: |
| 76 QuitMessageLoopErrorHandler() {} |
| 77 ~QuitMessageLoopErrorHandler() override {} |
| 78 |
| 79 // |ErrorHandler| implementation: |
| 80 void OnConnectionError() override { |
| 81 base::MessageLoop::current()->QuitWhenIdle(); |
| 82 } |
| 83 |
| 84 private: |
| 85 DISALLOW_COPY_AND_ASSIGN(QuitMessageLoopErrorHandler); |
| 86 }; |
| 87 |
| 88 // Tests that we can connect to a single service within a single app. |
| 89 TEST_F(ShellTestBaseTest, ConnectBasic) { |
| 90 InterfacePtr<TestService> service; |
| 91 ConnectToService(test_app_url(), &service); |
| 92 |
| 93 bool was_run = false; |
| 94 service->Ping(SetAndQuit<bool>(&was_run, true)); |
| 95 message_loop()->Run(); |
| 96 EXPECT_TRUE(was_run); |
| 97 EXPECT_FALSE(service.encountered_error()); |
| 98 |
| 99 service.reset(); |
| 100 |
| 101 // This will run until the test app has actually quit (which it will, |
| 102 // since we killed the only connection to it). |
| 103 message_loop()->Run(); |
| 104 } |
| 105 |
| 106 // Tests that trying to connect to a service fails properly if the service |
| 107 // doesn't exist. Implicit in this test is verification that the shell |
| 108 // terminates if no services are running. |
| 109 TEST_F(ShellTestBaseTest, ConnectInvalidService) { |
| 110 InterfacePtr<TestService> test_service; |
| 111 ConnectToService(GURL("mojo:non_existent_service"), &test_service); |
| 112 |
| 113 bool was_run = false; |
| 114 test_service->Ping(SetAndQuit<bool>(&was_run, true)); |
| 115 |
| 116 // This will quit because there's nothing running. |
| 117 message_loop()->Run(); |
| 118 EXPECT_FALSE(was_run); |
| 119 |
| 120 // It may have quit before an error was processed. |
| 121 if (!test_service.encountered_error()) { |
| 122 QuitMessageLoopErrorHandler quitter; |
| 123 test_service.set_error_handler(&quitter); |
| 124 message_loop()->Run(); |
| 125 EXPECT_TRUE(test_service.encountered_error()); |
| 126 } |
| 127 |
| 128 test_service.reset(); |
| 129 } |
| 130 |
| 131 // Tests that we can connect to a single service within a single app using |
| 132 // a network based loader instead of local files. |
| 133 // TODO(tim): Disabled because network service leaks NSS at exit, meaning |
| 134 // subsequent tests can't init properly. |
| 135 TEST_F(ShellTestBaseTest, DISABLED_ConnectBasicNetwork) { |
| 136 InterfacePtr<TestService> service; |
| 137 ConnectToService(test_app_url(), &service); |
| 138 |
| 139 bool was_run = false; |
| 140 service->Ping(SetAndQuit<bool>(&was_run, true)); |
| 141 message_loop()->Run(); |
| 142 EXPECT_TRUE(was_run); |
| 143 EXPECT_FALSE(service.encountered_error()); |
| 144 |
| 145 // Note that use of the network service is implicit in this test. |
| 146 // Since TestService is not the only service in use, the shell won't auto |
| 147 // magically exit when TestService is destroyed (unlike ConnectBasic). |
| 148 // Tearing down the shell context will kill connections. The shell loop will |
| 149 // exit as soon as no more apps are connected. |
| 150 // TODO(tim): crbug.com/392685. Calling this explicitly shouldn't be |
| 151 // necessary once the shell terminates if the primordial app exits, which |
| 152 // we could enforce here by resetting |service|. |
| 153 shell_context()->application_manager()->TerminateShellConnections(); |
| 154 message_loop()->Run(); // Waits for all connections to die. |
| 155 } |
| 156 |
| 157 // Tests that trying to connect to a service over network fails preoprly |
| 158 // if the service doesn't exist. |
| 159 // TODO(tim): Disabled because network service leaks NSS at exit, meaning |
| 160 // subsequent tests can't init properly. |
| 161 TEST_F(ShellTestBaseTest, DISABLED_ConnectInvalidServiceNetwork) { |
| 162 InterfacePtr<TestService> test_service; |
| 163 ConnectToService(GURL("http://example.com/non_existent_service"), |
| 164 &test_service); |
| 165 QuitMessageLoopErrorHandler quitter; |
| 166 test_service.set_error_handler(&quitter); |
| 167 bool was_run = false; |
| 168 test_service->Ping(SetAndQuit<bool>(&was_run, true)); |
| 169 message_loop()->Run(); |
| 170 EXPECT_TRUE(test_service.encountered_error()); |
| 171 |
| 172 // TODO(tim): crbug.com/392685. Calling this explicitly shouldn't be |
| 173 // necessary once the shell terminates if the primordial app exits, which |
| 174 // we could enforce here by resetting |service|. |
| 175 shell_context()->application_manager()->TerminateShellConnections(); |
| 176 message_loop()->Run(); // Waits for all connections to die. |
| 177 } |
| 178 |
| 179 // Similar to ConnectBasic, but causes the app to instantiate multiple |
| 180 // service implementation objects and verifies the shell can reach both. |
| 181 TEST_F(ShellTestBaseTest, ConnectMultipleInstancesPerApp) { |
| 182 { |
| 183 TestServicePtr service1, service2; |
| 184 ConnectToService(test_app_url(), &service1); |
| 185 ConnectToService(test_app_url(), &service2); |
| 186 |
| 187 bool was_run1 = false; |
| 188 bool was_run2 = false; |
| 189 service1->Ping(SetAndQuit<bool>(&was_run1, true)); |
| 190 message_loop()->Run(); |
| 191 service2->Ping(SetAndQuit<bool>(&was_run2, true)); |
| 192 message_loop()->Run(); |
| 193 EXPECT_TRUE(was_run1); |
| 194 EXPECT_TRUE(was_run2); |
| 195 EXPECT_FALSE(service1.encountered_error()); |
| 196 EXPECT_FALSE(service2.encountered_error()); |
| 197 } |
| 198 message_loop()->Run(); |
| 199 } |
| 200 |
| 201 // Tests that service A and service B, both in App 1, can talk to each other |
| 202 // and parameters are passed around properly. |
| 203 TEST_F(ShellTestBaseTest, ConnectDifferentServicesInSingleApp) { |
| 204 // Have a TestService GetPartyTime on a TestTimeService in the same app. |
| 205 int64 time_message; |
| 206 TestServicePtr service; |
| 207 ConnectToService(test_app_url(), &service); |
| 208 service->ConnectToAppAndGetTime(test_app_url().spec(), |
| 209 SetAndQuit<int64>(&time_message)); |
| 210 message_loop()->Run(); |
| 211 |
| 212 // Verify by hitting the TimeService directly. |
| 213 TestTimeServicePtr time_service; |
| 214 ConnectToService(test_app_url(), &time_service); |
| 215 int64 party_time; |
| 216 time_service->GetPartyTime(SetAndQuit<int64>(&party_time)); |
| 217 message_loop()->Run(); |
| 218 |
| 219 EXPECT_EQ(time_message, party_time); |
| 220 } |
| 221 |
| 222 // Tests that a service A in App 1 can talk to service B in App 2 and |
| 223 // parameters are passed around properly. |
| 224 TEST_F(ShellTestBaseTest, ConnectDifferentServicesInDifferentApps) { |
| 225 int64 time_message; |
| 226 TestServicePtr service; |
| 227 ConnectToService(test_app_url(), &service); |
| 228 service->ConnectToAppAndGetTime("mojo:test_request_tracker_app", |
| 229 SetAndQuit<int64>(&time_message)); |
| 230 message_loop()->Run(); |
| 231 |
| 232 // Verify by hitting the TimeService in the request tracker app directly. |
| 233 TestTimeServicePtr time_service; |
| 234 ConnectToService(GURL("mojo:test_request_tracker_app"), &time_service); |
| 235 int64 party_time; |
| 236 time_service->GetPartyTime(SetAndQuit<int64>(&party_time)); |
| 237 message_loop()->Run(); |
| 238 |
| 239 EXPECT_EQ(time_message, party_time); |
| 240 } |
| 241 |
| 242 // Tests that service A in App 1 can be a client of service B in App 2. |
| 243 TEST_F(ShellTestBaseTest, ConnectServiceAsClientOfSeparateApp) { |
| 244 TestServicePtr service; |
| 245 ConnectToService(test_app_url(), &service); |
| 246 service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure()); |
| 247 service->Ping(Callback<void()>()); |
| 248 message_loop()->Run(); |
| 249 |
| 250 for (int i = 0; i < 8; i++) |
| 251 service->Ping(Callback<void()>()); |
| 252 service->Ping(message_loop()->QuitWhenIdleClosure()); |
| 253 message_loop()->Run(); |
| 254 |
| 255 // If everything worked properly, the tracking service should report |
| 256 // 10 pings to TestService. |
| 257 std::vector<ServiceReport> reports; |
| 258 GetReport(&reports); |
| 259 ASSERT_EQ(1U, reports.size()); |
| 260 EXPECT_EQ(TestService::Name_, reports[0].service_name); |
| 261 EXPECT_EQ(10U, reports[0].total_requests); |
| 262 } |
| 263 |
| 264 // Connect several services together and use the tracking service to verify |
| 265 // communication. |
| 266 TEST_F(ShellTestBaseTest, ConnectManyClientsAndServices) { |
| 267 TestServicePtr service; |
| 268 TestTimeServicePtr time_service; |
| 269 |
| 270 // Make a request to the TestService and have it contact TimeService in the |
| 271 // tracking app. Do all this with tracking enabled, meaning both services |
| 272 // are connected as clients of the TrackedRequestService. |
| 273 ConnectToService(test_app_url(), &service); |
| 274 service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure()); |
| 275 message_loop()->Run(); |
| 276 for (int i = 0; i < 5; i++) |
| 277 service->Ping(Callback<void()>()); |
| 278 int64 time_result; |
| 279 service->ConnectToAppAndGetTime("mojo:test_request_tracker_app", |
| 280 SetAndQuit<int64>(&time_result)); |
| 281 message_loop()->Run(); |
| 282 |
| 283 // Also make a few requests to the TimeService in the test_app. |
| 284 ConnectToService(test_app_url(), &time_service); |
| 285 time_service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure()); |
| 286 time_service->GetPartyTime(Callback<void(uint64_t)>()); |
| 287 message_loop()->Run(); |
| 288 for (int i = 0; i < 18; i++) |
| 289 time_service->GetPartyTime(Callback<void(uint64_t)>()); |
| 290 // Flush the tasks with one more to quit. |
| 291 int64 party_time = 0; |
| 292 time_service->GetPartyTime(SetAndQuit<int64>(&party_time)); |
| 293 message_loop()->Run(); |
| 294 |
| 295 std::vector<ServiceReport> reports; |
| 296 GetReport(&reports); |
| 297 ASSERT_EQ(3U, reports.size()); |
| 298 EXPECT_EQ(TestService::Name_, reports[0].service_name); |
| 299 EXPECT_EQ(6U, reports[0].total_requests); |
| 300 EXPECT_EQ(TestTimeService::Name_, reports[1].service_name); |
| 301 EXPECT_EQ(1U, reports[1].total_requests); |
| 302 EXPECT_EQ(TestTimeService::Name_, reports[2].service_name); |
| 303 EXPECT_EQ(20U, reports[2].total_requests); |
| 304 } |
| 305 |
| 306 } // namespace |
| 307 } // namespace test |
| 308 } // namespace shell |
| 309 } // namespace mojo |
OLD | NEW |