1 //
2 //
3 // Copyright 2017 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 //******************************************************************************
20 // This test verifies that various stack configurations result in the set of
21 // filters that we expect.
22 //
23 // This is akin to a golden-file test, and suffers the same disadvantages and
24 // advantages: it reflects that the code as written has not been modified - and
25 // valid code modifications WILL break this test and it will need updating.
26 //
27 // The intent therefore is to allow code reviewers to more easily catch changes
28 // that perturb the generated list of channel filters in different
29 // configurations and assess whether such a change is correct and desirable.
30 //
31
32 #include <grpc/grpc.h>
33 #include <grpc/impl/channel_arg_names.h>
34
35 #include <algorithm>
36 #include <memory>
37 #include <string>
38 #include <vector>
39
40 #include "absl/log/check.h"
41 #include "absl/memory/memory.h"
42 #include "absl/strings/string_view.h"
43 #include "gtest/gtest.h"
44 #include "src/core/config/core_configuration.h"
45 #include "src/core/lib/channel/channel_args.h"
46 #include "src/core/lib/channel/channel_stack.h"
47 #include "src/core/lib/channel/channel_stack_builder_impl.h"
48 #include "src/core/lib/experiments/experiments.h"
49 #include "src/core/lib/iomgr/endpoint.h"
50 #include "src/core/lib/iomgr/exec_ctx.h"
51 #include "src/core/lib/iomgr/iomgr_fwd.h"
52 #include "src/core/lib/surface/channel_init.h"
53 #include "src/core/lib/surface/channel_stack_type.h"
54 #include "src/core/lib/transport/transport.h"
55 #include "test/core/test_util/test_config.h"
56
57 namespace {
58 class FakeTransport final : public grpc_core::Transport {
59 public:
FakeTransport(absl::string_view transport_name)60 explicit FakeTransport(absl::string_view transport_name)
61 : transport_name_(transport_name) {}
62
filter_stack_transport()63 grpc_core::FilterStackTransport* filter_stack_transport() override {
64 return nullptr;
65 }
client_transport()66 grpc_core::ClientTransport* client_transport() override { return nullptr; }
server_transport()67 grpc_core::ServerTransport* server_transport() override { return nullptr; }
68
GetTransportName() const69 absl::string_view GetTransportName() const override {
70 return transport_name_;
71 }
SetPollset(grpc_stream *,grpc_pollset *)72 void SetPollset(grpc_stream*, grpc_pollset*) override {}
SetPollsetSet(grpc_stream *,grpc_pollset_set *)73 void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
PerformOp(grpc_transport_op *)74 void PerformOp(grpc_transport_op*) override {}
Orphan()75 void Orphan() override {}
76
77 private:
78 absl::string_view transport_name_;
79 };
80 } // namespace
81
MakeStack(const char * transport_name,grpc_core::ChannelArgs channel_args,grpc_channel_stack_type channel_stack_type)82 std::vector<std::string> MakeStack(const char* transport_name,
83 grpc_core::ChannelArgs channel_args,
84 grpc_channel_stack_type channel_stack_type) {
85 // create phony channel stack
86 std::unique_ptr<FakeTransport> fake_transport;
87 if (transport_name != nullptr) {
88 fake_transport = absl::make_unique<FakeTransport>(transport_name);
89 channel_args = channel_args.SetObject(fake_transport.get());
90 }
91 grpc_core::ChannelStackBuilderImpl builder("test", channel_stack_type,
92 channel_args);
93 builder.SetTarget("foo.test.google.fr");
94 {
95 grpc_core::ExecCtx exec_ctx;
96 CHECK(grpc_core::CoreConfiguration::Get().channel_init().CreateStack(
97 &builder));
98 }
99
100 std::vector<std::string> parts;
101 for (const auto& entry : *builder.mutable_stack()) {
102 parts.push_back(std::string(entry->name.name()));
103 }
104
105 return parts;
106 }
107
TEST(ChannelStackFilters,LooksAsExpected)108 TEST(ChannelStackFilters, LooksAsExpected) {
109 const auto minimal_stack_args =
110 grpc_core::ChannelArgs().Set(GRPC_ARG_MINIMAL_STACK, true);
111 const auto no_args = grpc_core::ChannelArgs();
112
113 EXPECT_EQ(
114 MakeStack("unknown", minimal_stack_args, GRPC_CLIENT_DIRECT_CHANNEL),
115 std::vector<std::string>({"authority", "connected"}));
116 EXPECT_EQ(MakeStack("unknown", minimal_stack_args, GRPC_CLIENT_SUBCHANNEL),
117 std::vector<std::string>({"authority", "connected"}));
118 EXPECT_EQ(
119 MakeStack("unknown", minimal_stack_args, GRPC_SERVER_CHANNEL),
120 std::vector<std::string>({"server", "server_call_tracer", "connected"}));
121
122 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_CLIENT_DIRECT_CHANNEL),
123 std::vector<std::string>(
124 {"authority", "http-client", "compression", "connected"}));
125 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_CLIENT_SUBCHANNEL),
126 std::vector<std::string>(
127 {"authority", "http-client", "compression", "connected"}));
128 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_SERVER_CHANNEL),
129 std::vector<std::string>({"server", "http-server", "compression",
130 "server_call_tracer", "connected"}));
131 EXPECT_EQ(MakeStack(nullptr, minimal_stack_args, GRPC_CLIENT_CHANNEL),
132 std::vector<std::string>({"client-channel"}));
133
134 // tests with a default stack
135
136 EXPECT_EQ(
137 MakeStack("unknown", no_args, GRPC_CLIENT_DIRECT_CHANNEL),
138 std::vector<std::string>({"authority", "message_size", "connected"}));
139 EXPECT_EQ(
140 MakeStack("unknown", no_args, GRPC_CLIENT_SUBCHANNEL),
141 std::vector<std::string>({"authority", "message_size", "connected"}));
142 EXPECT_EQ(MakeStack("unknown", no_args, GRPC_SERVER_CHANNEL),
143 std::vector<std::string>(
144 {"server", "message_size", "server_call_tracer", "connected"}));
145
146 EXPECT_EQ(
147 MakeStack("chttp2", no_args, GRPC_CLIENT_DIRECT_CHANNEL),
148 std::vector<std::string>({"authority", "message_size", "http-client",
149 "compression", "connected"}));
150 EXPECT_EQ(
151 MakeStack("chttp2", no_args, GRPC_CLIENT_SUBCHANNEL),
152 std::vector<std::string>({"authority", "message_size", "http-client",
153 "compression", "connected"}));
154
155 EXPECT_EQ(MakeStack("chttp2", no_args, GRPC_SERVER_CHANNEL),
156 std::vector<std::string>({"server", "message_size", "http-server",
157 "compression", "server_call_tracer",
158 "connected"}));
159 EXPECT_EQ(MakeStack(nullptr, no_args, GRPC_CLIENT_CHANNEL),
160 std::vector<std::string>({"client_idle", "client-channel"}));
161 }
162
main(int argc,char ** argv)163 int main(int argc, char** argv) {
164 grpc::testing::TestEnvironment env(&argc, argv);
165 ::testing::InitGoogleTest(&argc, argv);
166 grpc_init();
167 int r = RUN_ALL_TESTS();
168 grpc_shutdown();
169 return r;
170 }
171