| 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 |
|---|
Chromium Code Reviews
Issue 1091513005:
Separate mojo/shell into a runner and the application manager (shell) (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master