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
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/fuchsia/test_component_context_for_process.h"
#include <fidl/fuchsia.buildinfo/cpp/fidl.h>
#include <fuchsia/buildinfo/cpp/fidl.h>
#include <lib/async/default.h>
#include <lib/sys/cpp/component_context.h>
#include <string_view>
#include "base/fuchsia/fuchsia_component_connect.h"
#include "base/fuchsia/fuchsia_logging.h"
#include "base/fuchsia/process_context.h"
#include "base/fuchsia/scoped_service_binding.h"
#include "base/fuchsia/test_interface_impl.h"
#include "base/fuchsia/test_interface_natural_impl.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "base/testfidl/cpp/fidl.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
class TestComponentContextForProcessTest : public testing::Test {
public:
TestComponentContextForProcessTest()
: task_environment_(base::test::TaskEnvironment::MainThreadType::IO) {}
bool CanConnectToTestInterfaceServiceHlcpp() {
auto test_interface_ptr =
ComponentContextForProcess()->svc()->Connect<testfidl::TestInterface>();
return VerifyTestInterface(test_interface_ptr) == ZX_OK;
}
bool CanConnectToTestInterfaceServiceNatural() {
auto client_end =
fuchsia_component::Connect<base_testfidl::TestInterface>();
EXPECT_TRUE(client_end.is_ok()) << client_end.status_string();
fidl::Client client(std::move(client_end.value()),
async_get_default_dispatcher());
return VerifyTestInterface(client) == ZX_OK;
}
bool HasPublishedTestInterfaceHlcpp() {
auto test_interface_ptr =
test_context_.published_services()->Connect<testfidl::TestInterface>();
return VerifyTestInterface(test_interface_ptr) == ZX_OK;
}
bool HasPublishedTestInterfaceNatural() {
auto client_end =
fuchsia_component::ConnectAt<base_testfidl::TestInterface>(
test_context_.published_services_natural());
EXPECT_TRUE(client_end.is_ok()) << client_end.status_string();
fidl::Client client(std::move(client_end.value()),
async_get_default_dispatcher());
return VerifyTestInterface(client) == ZX_OK;
}
protected:
const base::test::SingleThreadTaskEnvironment task_environment_;
base::TestComponentContextForProcess test_context_;
};
TEST_F(TestComponentContextForProcessTest, NoServices) {
// No services should be available.
EXPECT_FALSE(CanConnectToTestInterfaceServiceHlcpp());
EXPECT_FALSE(CanConnectToTestInterfaceServiceNatural());
}
TEST_F(TestComponentContextForProcessTest, InjectTestInterface) {
TestInterfaceImpl test_interface_impl;
// Publish a fake TestInterface for the process' ComponentContext to expose.
base::ScopedServiceBinding<testfidl::TestInterface> service_binding(
test_context_.additional_services(), &test_interface_impl);
// Verify that the TestInterface is accessible & usable.
EXPECT_TRUE(CanConnectToTestInterfaceServiceHlcpp());
EXPECT_TRUE(CanConnectToTestInterfaceServiceNatural());
}
TEST_F(TestComponentContextForProcessTest, PublishTestInterface) {
TestInterfaceImpl test_interface_impl;
// Publish TestInterface to the process' outgoing-directory.
base::ScopedServiceBinding<testfidl::TestInterface> service_binding(
ComponentContextForProcess()->outgoing().get(), &test_interface_impl);
// Attempt to use the TestInterface from the outgoing-directory.
EXPECT_TRUE(HasPublishedTestInterfaceHlcpp());
EXPECT_TRUE(HasPublishedTestInterfaceNatural());
}
TEST_F(TestComponentContextForProcessTest, ProvideSystemService) {
// Expose fuchsia.buildinfo.Provider through the
// TestComponentContextForProcess. This service was chosen because it is one
// of the ambient services in Fuchsia's hermetic environment for Chromium
// tests.
const std::string_view kServiceNames[] = {
::fuchsia::buildinfo::Provider::Name_};
test_context_.AddServices(kServiceNames);
// Connect to the BuildInfo provider service via the process
// TestComponentContextForProcess.
RunLoop wait_loop;
auto provider = ComponentContextForProcess()
->svc()
->Connect<::fuchsia::buildinfo::Provider>();
provider.set_error_handler(
[quit_loop = wait_loop.QuitClosure()](zx_status_t status) {
ZX_LOG(ERROR, status);
ADD_FAILURE();
quit_loop.Run();
});
// If the BuildInfo service is actually connected then GetBuildInfo() will
// return a result, otherwise the channel will be observed closing (as above).
provider->GetBuildInfo([quit_loop = wait_loop.QuitClosure()](
auto build_info) { quit_loop.Run(); });
wait_loop.Run();
}
TEST_F(TestComponentContextForProcessTest, ProvideSystemServiceNatural) {
// Expose fuchsia.buildinfo.Provider through the
// TestComponentContextForProcess. This service was chosen because it is one
// of the ambient services in Fuchsia's hermetic environment for Chromium
// tests.
const std::string_view kServiceNames[] = {
fidl::DiscoverableProtocolName<fuchsia_buildinfo::Provider>};
test_context_.AddServices(kServiceNames);
// Connect to the BuildInfo provider service via the process
// TestComponentContextForProcess.
RunLoop wait_loop;
auto client_end = fuchsia_component::Connect<fuchsia_buildinfo::Provider>();
ASSERT_TRUE(client_end.is_ok());
fidl::Client provider(std::move(client_end.value()),
async_get_default_dispatcher());
// If the BuildInfo service is actually connected then GetBuildInfo() will
// return a result, otherwise the bindings will report an error.
provider->GetBuildInfo().Then([quit_loop =
wait_loop.QuitClosure()](auto build_info) {
EXPECT_FALSE(build_info.is_error()) << build_info.error_value().status();
quit_loop.Run();
});
wait_loop.Run();
}
} // namespace base
|
