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 <algorithm>
33 #include <memory>
34 #include <string>
35 #include <vector>
36
37 #include "absl/memory/memory.h"
38 #include "absl/strings/string_view.h"
39 #include "gtest/gtest.h"
40
41 #include <grpc/grpc.h>
42 #include <grpc/impl/channel_arg_names.h>
43 #include <grpc/support/log.h>
44
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/config/core_configuration.h"
49 #include "src/core/lib/experiments/experiments.h"
50 #include "src/core/lib/iomgr/endpoint.h"
51 #include "src/core/lib/iomgr/exec_ctx.h"
52 #include "src/core/lib/iomgr/iomgr_fwd.h"
53 #include "src/core/lib/surface/channel_init.h"
54 #include "src/core/lib/surface/channel_stack_type.h"
55 #include "src/core/lib/transport/transport.h"
56 #include "test/core/util/test_config.h"
57
58 namespace {
59 class FakeTransport final : public grpc_core::Transport {
60 public:
FakeTransport(absl::string_view transport_name)61 explicit FakeTransport(absl::string_view transport_name)
62 : transport_name_(transport_name) {}
63
filter_stack_transport()64 grpc_core::FilterStackTransport* filter_stack_transport() override {
65 return nullptr;
66 }
client_transport()67 grpc_core::ClientTransport* client_transport() override { return nullptr; }
server_transport()68 grpc_core::ServerTransport* server_transport() override { return nullptr; }
69
GetTransportName() const70 absl::string_view GetTransportName() const override {
71 return transport_name_;
72 }
SetPollset(grpc_stream *,grpc_pollset *)73 void SetPollset(grpc_stream*, grpc_pollset*) override {}
SetPollsetSet(grpc_stream *,grpc_pollset_set *)74 void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
PerformOp(grpc_transport_op *)75 void PerformOp(grpc_transport_op*) override {}
GetEndpoint()76 grpc_endpoint* GetEndpoint() override { return nullptr; }
Orphan()77 void Orphan() override {}
78
79 private:
80 absl::string_view transport_name_;
81 };
82 } // namespace
83
MakeStack(const char * transport_name,grpc_core::ChannelArgs channel_args,grpc_channel_stack_type channel_stack_type)84 std::vector<std::string> MakeStack(const char* transport_name,
85 grpc_core::ChannelArgs channel_args,
86 grpc_channel_stack_type channel_stack_type) {
87 // create phony channel stack
88 std::unique_ptr<FakeTransport> fake_transport;
89 if (transport_name != nullptr) {
90 fake_transport = absl::make_unique<FakeTransport>(transport_name);
91 channel_args = channel_args.SetObject(fake_transport.get());
92 }
93 grpc_core::ChannelStackBuilderImpl builder("test", channel_stack_type,
94 channel_args);
95 builder.SetTarget("foo.test.google.fr");
96 {
97 grpc_core::ExecCtx exec_ctx;
98 GPR_ASSERT(grpc_core::CoreConfiguration::Get().channel_init().CreateStack(
99 &builder));
100 }
101
102 std::vector<std::string> parts;
103 for (const auto& entry : *builder.mutable_stack()) {
104 const char* name = entry->name;
105 if (name == nullptr) continue;
106 parts.push_back(name);
107 }
108
109 return parts;
110 }
111
TEST(ChannelStackFilters,LooksAsExpected)112 TEST(ChannelStackFilters, LooksAsExpected) {
113 const auto minimal_stack_args =
114 grpc_core::ChannelArgs().Set(GRPC_ARG_MINIMAL_STACK, true);
115 const auto no_args = grpc_core::ChannelArgs();
116
117 EXPECT_EQ(
118 MakeStack("unknown", minimal_stack_args, GRPC_CLIENT_DIRECT_CHANNEL),
119 std::vector<std::string>({"authority", "connected"}));
120 EXPECT_EQ(MakeStack("unknown", minimal_stack_args, GRPC_CLIENT_SUBCHANNEL),
121 std::vector<std::string>({"authority", "connected"}));
122 EXPECT_EQ(
123 MakeStack("unknown", minimal_stack_args, GRPC_SERVER_CHANNEL),
124 std::vector<std::string>({"server", "server_call_tracer", "connected"}));
125
126 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_CLIENT_DIRECT_CHANNEL),
127 std::vector<std::string>(
128 {"authority", "http-client", "compression", "connected"}));
129 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_CLIENT_SUBCHANNEL),
130 std::vector<std::string>(
131 {"authority", "http-client", "compression", "connected"}));
132 EXPECT_EQ(MakeStack("chttp2", minimal_stack_args, GRPC_SERVER_CHANNEL),
133 std::vector<std::string>({"server", "http-server", "compression",
134 "server_call_tracer", "connected"}));
135 EXPECT_EQ(MakeStack(nullptr, minimal_stack_args, GRPC_CLIENT_CHANNEL),
136 std::vector<std::string>({"client-channel"}));
137
138 // tests with a default stack
139
140 EXPECT_EQ(MakeStack("unknown", no_args, GRPC_CLIENT_DIRECT_CHANNEL),
141 std::vector<std::string>(
142 {"authority", "message_size", "deadline", "connected"}));
143 EXPECT_EQ(
144 MakeStack("unknown", no_args, GRPC_CLIENT_SUBCHANNEL),
145 std::vector<std::string>({"authority", "message_size", "connected"}));
146 EXPECT_EQ(MakeStack("unknown", no_args, GRPC_SERVER_CHANNEL),
147 std::vector<std::string>({"server", "message_size", "deadline",
148 "server_call_tracer", "connected"}));
149
150 EXPECT_EQ(
151 MakeStack("chttp2", no_args, GRPC_CLIENT_DIRECT_CHANNEL),
152 std::vector<std::string>({"authority", "message_size", "deadline",
153 "http-client", "compression", "connected"}));
154 EXPECT_EQ(
155 MakeStack("chttp2", no_args, GRPC_CLIENT_SUBCHANNEL),
156 std::vector<std::string>({"authority", "message_size", "http-client",
157 "compression", "connected"}));
158
159 EXPECT_EQ(MakeStack("chttp2", no_args, GRPC_SERVER_CHANNEL),
160 std::vector<std::string>({"server", "message_size", "deadline",
161 "http-server", "compression",
162 "server_call_tracer", "connected"}));
163 EXPECT_EQ(MakeStack(nullptr, no_args, GRPC_CLIENT_CHANNEL),
164 std::vector<std::string>({"client_idle", "client-channel"}));
165 }
166
main(int argc,char ** argv)167 int main(int argc, char** argv) {
168 grpc::testing::TestEnvironment env(&argc, argv);
169 ::testing::InitGoogleTest(&argc, argv);
170 grpc_init();
171 int r = RUN_ALL_TESTS();
172 grpc_shutdown();
173 return r;
174 }
175