Debian Codegraph @

router/src/routing/tests/plugin/test_plugin.cc

raw
1 /*
2 Copyright (c) 2015, 2026, Oracle and/or its affiliates.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2.0,
6 as published by the Free Software Foundation.
7
8 This program is designed to work with certain software (including
9 but not limited to OpenSSL) that is licensed under separate terms,
10 as designated in a particular file or component or in included license
11 documentation. The authors of MySQL hereby grant you an additional
12 permission to link the program and your derivative works with the
13 separately licensed software that they have either included with
14 the program or referenced in the documentation.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 */
25
26 #include <chrono>
27 #include <fstream>
28 #include <functional>
29 #include <system_error>
30
31 #ifndef _WIN32
32 #include <unistd.h>
33 #endif
34
35 #include <gmock/gmock.h>
36 #include <gtest/gtest-matchers.h>
37 #include <gtest/gtest.h>
38
39 #include "mysql/harness/config_parser.h"
40 #include "mysql/harness/filesystem.h" // Path
41 #include "mysql/harness/logging/logging.h"
42 #include "mysql/harness/plugin.h" // AppInfo
43 #include "mysqlrouter/io_backend.h"
44 #include "mysqlrouter/io_component.h"
45
46 #include "gtest_consoleoutput.h"
47 #include "mysql_routing.h"
48 #include "plugin_config.h"
49 #include "router_test_helpers.h"
50 #include "tcp_port_pool.h"
51 #include "test/helpers.h" // init_test_logger
52
53 // since this function is only meant to be used here (for testing purposes),
54 // it's not available in the headers.
55 void validate_socket_info_test_proxy(
56 const std::string &err_prefix, const mysql_harness::ConfigSection *section,
57 const RoutingPluginConfig &config);
58
59 using mysql_harness::Path;
60 using ::testing::HasSubstr;
61 using ::testing::IsEmpty;
62 using ::testing::IsNull;
63 using ::testing::NotNull;
64 using ::testing::StrEq;
65
66 // define what is available in routing_plugin.cc
67 extern const mysql_harness::AppInfo *g_app_info;
68
69 string g_cwd;
70 Path g_origin;
71
72 class RoutingPluginTests : public ConsoleOutputTest {
73 TcpPortPool tcp_port_pool_;
74
75 protected:
76 void SetUp() override {
77 set_origin(g_origin);
78 ConsoleOutputTest::SetUp();
79 config_path = std::make_unique<Path>(g_cwd);
80 config_path->append("test_routing_plugin.conf");
81 cmd = app_mysqlrouter->str() + " -c " + config_path->str();
82
83 bind_address =
84 "127.0.0.1:" + std::to_string(tcp_port_pool_.get_next_available());
85 destinations =
86 "127.0.0.1:" + std::to_string(tcp_port_pool_.get_next_available());
87 socket = rundir + "/unix_socket";
88 routing_strategy = "round-robin";
89 mode = "read-only";
90 connect_timeout = "1";
91 client_connect_timeout = "9";
92 max_connect_errors = "100";
93 protocol = "classic";
94
95 IoComponent::get_instance().init(1, IoBackend::preferred());
96 }
97
98 bool in_missing(std::vector<std::string> missing, std::string needle) {
99 return std::find(missing.begin(), missing.end(), needle) != missing.end();
100 }
101
102 void reset_config(std::vector<std::string> missing = {},
103 bool add_break = false) {
104 std::ofstream ofs_config(config_path->str());
105 if (ofs_config.good()) {
106 ofs_config << "[DEFAULT]\n";
107 ofs_config << "logging_folder =\n";
108 ofs_config << "plugin_folder = " << plugin_dir->str() << "\n";
109 ofs_config << "runtime_folder = " << temp_dir->str() << "\n";
110 ofs_config << "config_folder = " << temp_dir->str() << "\n";
111 ofs_config << "data_folder = " << temp_dir->str() << "\n\n";
112 ofs_config << "[routing:tests]\n";
113
114 using ConfigOption = std::pair<std::string, std::string &>;
115 std::vector<ConfigOption> routing_config_options{
116 {"bind_address", std::ref(bind_address)},
117 {"socket", std::ref(socket)},
118 {"destinations", std::ref(destinations)},
119 {"routing_strategy", std::ref(routing_strategy)},
120 {"mode", std::ref(mode)},
121 {"connect_timeout", std::ref(connect_timeout)},
122 {"client_connect_timeout", std::ref(client_connect_timeout)},
123 {"max_connect_errors", std::ref(max_connect_errors)},
124 {"protocol", std::ref(protocol)}};
125 for (auto &option : routing_config_options) {
126 if (!in_missing(missing, option.first)) {
127 ofs_config << option.first << " = " << option.second << "\n";
128 }
129 }
130
131 // Following is an incorrect [routing] entry. If the above is valid, this
132 // will make sure Router stops.
133 if (add_break) {
134 ofs_config << "\n[routing:break]\n";
135 }
136
137 ofs_config << "\n";
138 ofs_config.close();
139 }
140 }
141
142 void TearDown() override {
143 if (unlink(config_path->c_str()) == -1) {
144 if (errno != ENOENT) {
145 auto ec = std::error_code{errno, std::generic_category()};
146 // File missing is OK.
147 std::cerr << "Failed removing " << config_path->str() << ": "
148 << ec.message() << "(" << ec.value() << ")" << std::endl;
149 }
150 }
151 ConsoleOutputTest::TearDown();
152 }
153
154 const string plugindir = "path/to/plugindir";
155 const string logdir = "/path/to/logdir";
156 const string program = "routing_plugin_test";
157 const string rundir = "/path/to/rundir";
158 const string cfgdir = "/path/to/cfgdir";
159 const string datadir = "/path/to/datadir";
160 string bind_address;
161 string destinations;
162 string socket;
163 string routing_strategy;
164 string mode;
165 string connect_timeout;
166 string client_connect_timeout;
167 string max_connect_errors;
168 string protocol;
169
170 std::unique_ptr<Path> config_path;
171 std::string cmd;
172 };
173
174 TEST_F(RoutingPluginTests, PluginObject) {
175 ASSERT_EQ(harness_plugin_routing.abi_version, 0x0200U);
176 ASSERT_EQ(harness_plugin_routing.plugin_version,
177 static_cast<uint32_t>(VERSION_NUMBER(0, 0, 1)));
178 ASSERT_EQ(harness_plugin_routing.conflicts_length, 0U);
179 ASSERT_THAT(harness_plugin_routing.conflicts, IsNull());
180 ASSERT_THAT(harness_plugin_routing.deinit, NotNull());
181 ASSERT_THAT(harness_plugin_routing.brief,
182 StrEq("Routing MySQL connections between MySQL "
183 "clients/connectors and servers"));
184 }
185
186 TEST_F(RoutingPluginTests, InitAppInfo) {
187 ASSERT_THAT(g_app_info, IsNull());
188
189 mysql_harness::AppInfo test_app_info{
190 program.c_str(), plugindir.c_str(), logdir.c_str(), rundir.c_str(),
191 cfgdir.c_str(), datadir.c_str(), nullptr};
192
193 mysql_harness::PluginFuncEnv env(&test_app_info, nullptr);
194 harness_plugin_routing.init(&env);
195 ASSERT_TRUE(env.exit_ok());
196
197 ASSERT_THAT(g_app_info, Not(IsNull()));
198 ASSERT_THAT(program.c_str(), StrEq(g_app_info->program));
199
200 harness_plugin_routing.deinit(&env);
201 ASSERT_TRUE(env.exit_ok());
202 }
203
204 TEST_F(RoutingPluginTests, ListeningTcpSocket) {
205 mysql_harness::Config cfg;
206 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
207 section.add("destinations", "localhost:1234");
208 section.add("mode", "read-only");
209 section.add("bind_address", "127.0.0.1:15508");
210
211 EXPECT_NO_THROW({
212 RoutingPluginConfig config(&section);
213 validate_socket_info_test_proxy("", &section, config);
214 });
215 }
216
217 #ifndef _WIN32
218 TEST_F(RoutingPluginTests, ListeningUnixSocket) {
219 mysql_harness::Config cfg;
220 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
221 section.add("destinations", "localhost:1234");
222 section.add("mode", "read-only");
223 section.add("socket", "./socket"); // if this test fails, check if you don't
224 // have this file hanging around
225
226 EXPECT_NO_THROW({
227 RoutingPluginConfig config(&section);
228 validate_socket_info_test_proxy("", &section, config);
229 });
230 }
231
232 TEST_F(RoutingPluginTests, ListeningBothSockets) {
233 mysql_harness::Config cfg;
234 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
235 section.add("destinations", "localhost:1234");
236 section.add("mode", "read-only");
237 section.add("bind_address", "127.0.0.1:15508");
238 section.add("socket", "./socket"); // if this test fails, check if you don't
239 // have this file hanging around
240
241 EXPECT_NO_THROW({
242 RoutingPluginConfig config(&section);
243 validate_socket_info_test_proxy("", &section, config);
244 });
245 }
246
247 TEST_F(RoutingPluginTests, TwoUnixSocketsWithoutTcp) {
248 mysql_harness::Config cfg;
249 mysql_harness::ConfigSection &section1 = cfg.add("routing", "test_route1");
250 section1.add("destinations", "localhost:1234");
251 section1.add("mode", "read-only");
252 section1.add("socket", "./socket1");
253 mysql_harness::ConfigSection &section2 = cfg.add("routing", "test_route2");
254 section2.add("destinations", "localhost:1234");
255 section2.add("mode", "read-only");
256 section2.add("socket", "./socket2");
257
258 mysql_harness::AppInfo info;
259 info.config = &cfg;
260 mysql_harness::PluginFuncEnv env(&info, nullptr);
261
262 EXPECT_NO_THROW({ harness_plugin_routing.init(&env); });
263
264 harness_plugin_routing.deinit(&env);
265 }
266
267 TEST_F(RoutingPluginTests, TwoUnixSocketsWithTcp) {
268 mysql_harness::Config cfg;
269 mysql_harness::ConfigSection &section1 = cfg.add("routing", "test_route1");
270 section1.add("destinations", "localhost:1234");
271 section1.add("mode", "read-only");
272 section1.add("bind_address", "127.0.0.1:15501");
273 section1.add("socket", "./socket1");
274 mysql_harness::ConfigSection &section2 = cfg.add("routing", "test_route2");
275 section2.add("destinations", "localhost:1234");
276 section2.add("mode", "read-only");
277 section2.add("bind_address", "127.0.0.1:15502");
278 section2.add("socket", "./socket2");
279
280 mysql_harness::AppInfo info;
281 info.config = &cfg;
282 mysql_harness::PluginFuncEnv env(&info, nullptr);
283
284 EXPECT_NO_THROW({ harness_plugin_routing.init(&env); });
285
286 harness_plugin_routing.deinit(&env);
287 ASSERT_TRUE(env.exit_ok());
288 }
289
290 static std::string make_string(size_t len, char c = 'a') {
291 std::string res(len, c);
292
293 assert(res.length() == len);
294
295 return res;
296 }
297
298 static void test_socket_length(const std::string &socket_name, size_t max_len) {
299 mysql_harness::Config cfg;
300 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
301 section.add("destinations", "localhost:1234");
302 section.add("mode", "read-only");
303 section.add("socket", socket_name);
304
305 if (socket_name.length() <= max_len) {
306 EXPECT_NO_THROW({
307 RoutingPluginConfig config(&section);
308 validate_socket_info_test_proxy("", &section, config);
309 });
310 } else {
311 EXPECT_THROW(RoutingPluginConfig config(&section), std::invalid_argument);
312 }
313 }
314
315 TEST_F(RoutingPluginTests, ListeningSocketNameLength) {
316 #ifndef _WIN32
317 const size_t MAX_SOCKET_NAME_LEN = sizeof(sockaddr_un().sun_path) - 1;
318 #else
319 // doesn't really matter
320 const size_t MAX_SOCKET_NAME_LEN = 100;
321 #endif
322
323 std::string socket_name;
324
325 socket_name = make_string(MAX_SOCKET_NAME_LEN - 1);
326 test_socket_length(socket_name, MAX_SOCKET_NAME_LEN);
327
328 socket_name = make_string(MAX_SOCKET_NAME_LEN);
329 test_socket_length(socket_name, MAX_SOCKET_NAME_LEN);
330
331 socket_name = make_string(MAX_SOCKET_NAME_LEN + 1);
332 test_socket_length(socket_name, MAX_SOCKET_NAME_LEN);
333 }
334
335 TEST_F(RoutingPluginTests, TwoNonuniqueUnixSockets) {
336 // TODO add after implementing plugin lifecycle (WL9558),
337 // use TwoNonuniqueTcpSockets as an example
338 // (exception is thrown in plugin start(), in a separate thread)
339 }
340
341 #endif
342
343 TEST_F(RoutingPluginTests, TwoNonuniqueTcpSockets) {
344 mysql_harness::Config cfg;
345 mysql_harness::ConfigSection &section1 = cfg.add("routing", "test_route1");
346 section1.add("destinations", "localhost:1234");
347 section1.add("mode", "read-only");
348 section1.add("bind_address", "127.0.0.1:15508");
349 mysql_harness::ConfigSection &section2 = cfg.add("routing", "test_route2");
350 section2.add("destinations", "localhost:1234");
351 section2.add("mode", "read-only");
352 section2.add("bind_address", "127.0.0.1:15508");
353
354 mysql_harness::AppInfo info;
355 info.config = &cfg;
356 mysql_harness::PluginFuncEnv env(&info, nullptr);
357
358 try {
359 harness_plugin_routing.init(&env);
360
361 std::exception_ptr e;
362 std::tie(std::ignore, e) = env.pop_error();
363 if (e) std::rethrow_exception(e);
364
365 FAIL() << "Expected std::invalid_argument to be thrown";
366 } catch (const std::invalid_argument &e) {
367 EXPECT_STREQ(
368 "in [routing:test_route2]: duplicate IP or name found in bind_address "
369 "'127.0.0.1:15508'",
370 e.what());
371 SUCCEED();
372 } catch (...) {
373 FAIL() << "Expected std::invalid_argument to be thrown";
374 }
375 harness_plugin_routing.deinit(&env);
376 ASSERT_TRUE(env.exit_ok());
377 }
378
379 #ifndef _WIN32
380 TEST_F(RoutingPluginTests, EmptyUnixSocket) {
381 mysql_harness::Config cfg;
382 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
383 section.add("destinations", "localhost:1234");
384 section.add("mode", "read-only");
385 section.add("socket", "");
386
387 // If this not provided, RoutingPluginConfig() will throw with its own error,
388 // which will be misleading. This line should not influence throwing/not
389 // throwing the right error ("invalid socket ''")
390 section.add("bind_address", "127.0.0.1:15508");
391
392 try {
393 RoutingPluginConfig config(&section);
394 validate_socket_info_test_proxy("", &section, config);
395 FAIL() << "Expected std::invalid_argument to be thrown";
396 } catch (const std::invalid_argument &e) {
397 EXPECT_STREQ("invalid socket ''", e.what());
398 SUCCEED();
399 } catch (...) {
400 FAIL() << "Expected std::invalid_argument to be thrown";
401 }
402 }
403
404 TEST_F(RoutingPluginTests, ListeningHostIsInvalid) {
405 mysql_harness::Config cfg;
406 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
407 section.add("destinations", "localhost:1234");
408 section.add("mode", "read-only");
409 section.add("bind_address", "host.that.does.not..exist:15508");
410
411 try {
412 RoutingPluginConfig config(&section);
413 validate_socket_info_test_proxy("", &section, config);
414 FAIL() << "Expected std::invalid_argument to be thrown";
415 } catch (const std::invalid_argument &e) {
416 EXPECT_THAT(
417 e.what(),
418 ::testing::HasSubstr(
419 "'host.that.does.not..exist' in 'host.that.does.not..exist:15508' "
420 "is not a valid IP-address or hostname"));
421 SUCCEED();
422 } catch (const std::exception &e) {
423 FAIL() << "Expected std::invalid_argument to be thrown, got " << e.what();
424 }
425 }
426 #endif
427
428 TEST_F(RoutingPluginTests, Ipv6LinkLocal) {
429 mysql_harness::Config cfg;
430 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
431 section.add("destinations", "[fe80::3617:ebff:fecb:587e%3]:3306");
432 section.add("mode", "read-only");
433 section.add("bind_port", "6446");
434
435 try {
436 RoutingPluginConfig config(&section);
437 validate_socket_info_test_proxy("", &section, config);
438 } catch (const std::exception &e) {
439 FAIL() << "no exception, got: " << e.what();
440 }
441 }
442
443 TEST_F(RoutingPluginTests, InvalidIpv6) {
444 mysql_harness::Config cfg;
445 mysql_harness::ConfigSection &section = cfg.add("routing", "test_route");
446 section.add("destinations", "[fe80::3617:ebff:fecb:587e@3]:3306");
447 section.add("mode", "read-only");
448 section.add("bind_port", "6446");
449
450 try {
451 RoutingPluginConfig config(&section);
452 validate_socket_info_test_proxy("", &section, config);
453 FAIL() << "expected to throw, but succeeded";
454 } catch (const std::exception &e) {
455 EXPECT_THAT(e.what(),
456 ::testing::HasSubstr(
457 "address in destination list "
458 "'[fe80::3617:ebff:fecb:587e@3]:3306' is invalid"));
459 }
460 }
461
462 struct RoutingConfigParam {
463 const char *test_name;
464
465 std::vector<std::pair<const char *, const char *>> entries;
466
467 std::function<void(const RoutingPluginConfig &)> checker;
468 };
469
470 /**
471 * check valid routing config constructs.
472 */
473 class RoutingConfigTest
474 : public ::testing::Test,
475 public ::testing::WithParamInterface<RoutingConfigParam> {
476 public:
477 void SetUp() override {
478 cfg_.clear();
479
480 mysql_harness::ConfigSection &section = cfg_.add("routing", "test_route");
481 section.add("destinations", "127.0.0.1:3306");
482 section.add("mode", "read-only");
483 section.add("bind_port", "6446");
484 }
485 mysql_harness::Config cfg_{mysql_harness::Config::allow_keys};
486 };
487
488 /**
489 * check the option works in the [DEFAULT] section.
490 */
491 TEST_P(RoutingConfigTest, default_option) {
492 for (auto const &kv : GetParam().entries) {
493 cfg_.set_default(kv.first, kv.second);
494 }
495
496 mysql_harness::ConfigSection &section = cfg_.get("routing", "test_route");
497
498 try {
499 RoutingPluginConfig config(&section);
500
501 ASSERT_NO_FATAL_FAILURE(GetParam().checker(config));
502 } catch (const std::exception &e) {
503 FAIL() << e.what();
504 }
505 }
506
507 /**
508 * check the option works in the [routing] section.
509 */
510 TEST_P(RoutingConfigTest, section_option) {
511 mysql_harness::ConfigSection &section = cfg_.get("routing", "test_route");
512 for (auto const &kv : GetParam().entries) {
513 section.add(kv.first, kv.second);
514 }
515
516 try {
517 RoutingPluginConfig config(&section);
518
519 ASSERT_NO_FATAL_FAILURE(GetParam().checker(config));
520 } catch (const std::exception &e) {
521 FAIL() << e.what();
522 }
523 }
524
525 /**
526 * check the option works in the [routing] section and broken [DEFAULT] is
527 * ignored.
528 */
529 TEST_P(RoutingConfigTest, section_option_with_default) {
530 // set the 'key' to some value, just to check it isn't used
531 for (auto const &kv : GetParam().entries) {
532 cfg_.set_default(kv.first, "some-other-value");
533 }
534
535 mysql_harness::ConfigSection &section = cfg_.get("routing", "test_route");
536 for (auto const &kv : GetParam().entries) {
537 section.add(kv.first, kv.second);
538 }
539
540 try {
541 RoutingPluginConfig config(&section);
542
543 ASSERT_NO_FATAL_FAILURE(GetParam().checker(config));
544 } catch (const std::exception &e) {
545 FAIL() << e.what();
546 }
547 }
548
549 RoutingConfigParam routing_config_params[] = {
550
551 {"no_ssl_mode", // RT1_MODES_01, RT1_MODES_CERT_KEY_01,
552 // RT1_CERT_KEY_PARSE_03, RT1_CERT_KEY_PARSE_06
553 {},
554 [](const RoutingPluginConfig &config) {
555 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
556 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
557
558 ASSERT_EQ(config.source_ssl_cert, "");
559 ASSERT_EQ(config.source_ssl_key, "");
560 }},
561
562 // server-ssl-mode
563 {"server_ssl_mode_empty", // RT1_MODES_02
564 {
565 {"server_ssl_mode", ""},
566 },
567 [](const RoutingPluginConfig &config) {
568 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
569 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
570 }},
571
572 {"server_ssl_mode_as_client", // RT1_MODES_06
573 {
574 {"server_ssl_mode", "as_client"},
575 },
576 [](const RoutingPluginConfig &config) {
577 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
578 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
579 }},
580 {"server_ssl_mode_as_client_mixed_case", // RT1_ARGCASE_SM_04
581 {
582 {"server_ssl_mode", "as_Client"},
583 },
584 [](const RoutingPluginConfig &config) {
585 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
586 }},
587
588 // client-ssl-mode
589 {"client_ssl_mode_empty", // RT1_MODES_07
590 {
591 {"client_ssl_mode", ""},
592 },
593 [](const RoutingPluginConfig &config) {
594 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
595 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
596 }},
597
598 {"all_ssl_mode_empty", // RT1_MODES_08
599 {
600 {"client_ssl_mode", ""},
601 {"server_ssl_mode", ""},
602 },
603 [](const RoutingPluginConfig &config) {
604 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
605 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
606 }},
607
608 {"client_ssl_mode_empty_server_ssl_mode_as_client", // RT1_MODES_12
609 {
610 {"client_ssl_mode", ""},
611 {"server_ssl_mode", "As_Client"},
612 },
613 [](const RoutingPluginConfig &config) {
614 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
615 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
616 }},
617
618 {"client_ssl_mode_disabled", // RT1_MODES_13
619 {
620 {"client_ssl_mode", "disabled"},
621 },
622 [](const RoutingPluginConfig &config) {
623 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
624 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
625 }},
626 {"client_ssl_mode_disabled_mixed_case", // RT1_ARGCCASE_CM_01
627 {
628 {"client_ssl_mode", "DisAbled"},
629 },
630 [](const RoutingPluginConfig &config) {
631 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
632 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
633 }},
634 {"client_ssl_mode_disabled_server_ssl_mode_empty", // RT1_MODES_14
635 {
636 {"client_ssl_mode", "disabled"},
637 {"server_ssl_mode", ""},
638 },
639 [](const RoutingPluginConfig &config) {
640 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
641 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
642 }},
643 {"client_ssl_mode_disabled_server_ssl_mode_disabled", // RT1_MODES_15
644 {
645 {"client_ssl_mode", "disabled"},
646 {"server_ssl_mode", "disabled"},
647 },
648 [](const RoutingPluginConfig &config) {
649 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
650 ASSERT_THAT(config.dest_ssl_mode, SslMode::kDisabled);
651 }},
652 {"client_ssl_mode_disabled_server_ssl_mode_preferred", // RT1_MODES_16
653 {
654 {"client_ssl_mode", "disabled"},
655 {"server_ssl_mode", "preferred"},
656 },
657 [](const RoutingPluginConfig &config) {
658 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
659 ASSERT_THAT(config.dest_ssl_mode, SslMode::kPreferred);
660 }},
661 {"client_ssl_mode_disabled_server_ssl_mode_required", // RT1_MODES_17,
662 // RT1_ROUTING_VS_DEFAULT_02
663 {
664 {"client_ssl_mode", "disabled"},
665 {"server_ssl_mode", "required"},
666 },
667 [](const RoutingPluginConfig &config) {
668 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
669 ASSERT_THAT(config.dest_ssl_mode, SslMode::kRequired);
670 }},
671 {"client_ssl_mode_disabled_server_ssl_mode_as_client", // RT1_MODES_18
672 {
673 {"client_ssl_mode", "disabled"},
674 {"server_ssl_mode", "As_Client"},
675 },
676 [](const RoutingPluginConfig &config) {
677 ASSERT_THAT(config.source_ssl_mode, SslMode::kDisabled);
678 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
679 }},
680
681 {"client_ssl_mode_preferred", // RT1_MODES_19
682 {
683 {"client_ssl_mode", "preferred"},
684 {"client_ssl_cert", "some-cert.pem"},
685 {"client_ssl_key", "some-key.pem"},
686 },
687 [](const RoutingPluginConfig &config) {
688 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
689 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
690 }},
691 {"client_ssl_mode_preferred_mixed_case", // RT1_ARGCCASE_CM_02
692 {
693 {"client_ssl_mode", "PreFerred"},
694 {"client_ssl_cert", "some-cert.pem"},
695 {"client_ssl_key", "some-key.pem"},
696 },
697 [](const RoutingPluginConfig &config) {
698 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
699 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
700 }},
701 {"client_ssl_mode_preferred_server_ssl_mode_empty", // RT1_MODES_20
702 {
703 {"client_ssl_mode", "preferred"},
704 {"server_ssl_mode", ""},
705 {"client_ssl_cert", "some-cert.pem"},
706 {"client_ssl_key", "some-key.pem"},
707 },
708 [](const RoutingPluginConfig &config) {
709 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
710 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
711 }},
712 {"client_ssl_mode_preferred_server_ssl_mode_disabled", // RT1_MODES_21
713 {
714 {"client_ssl_mode", "preferred"},
715 {"server_ssl_mode", "disabled"},
716 {"client_ssl_cert", "some-cert.pem"},
717 {"client_ssl_key", "some-key.pem"},
718 },
719 [](const RoutingPluginConfig &config) {
720 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
721 ASSERT_THAT(config.dest_ssl_mode, SslMode::kDisabled);
722 }},
723 {"client_ssl_mode_preferred_server_ssl_mode_preferred", // RT1_MODES_22
724 {
725 {"client_ssl_mode", "preferred"},
726 {"server_ssl_mode", "preferred"},
727 {"client_ssl_cert", "some-cert.pem"},
728 {"client_ssl_key", "some-key.pem"},
729 },
730 [](const RoutingPluginConfig &config) {
731 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
732 ASSERT_THAT(config.dest_ssl_mode, SslMode::kPreferred);
733 }},
734 {"client_ssl_mode_preferred_server_ssl_mode_required", // RT1_MODES_23
735 {
736 {"client_ssl_mode", "preferred"},
737 {"server_ssl_mode", "required"},
738 {"client_ssl_cert", "some-cert.pem"},
739 {"client_ssl_key", "some-key.pem"},
740 },
741 [](const RoutingPluginConfig &config) {
742 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
743 ASSERT_THAT(config.dest_ssl_mode, SslMode::kRequired);
744 }},
745 {"client_ssl_mode_preferred_server_ssl_mode_as_client", // RT1_MODES_24
746 {
747 {"client_ssl_mode", "preferred"},
748 {"server_ssl_mode", "as_client"},
749 {"client_ssl_cert", "some-cert.pem"},
750 {"client_ssl_key", "some-key.pem"},
751 },
752 [](const RoutingPluginConfig &config) {
753 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
754 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
755 }},
756 {"client_ssl_mode_preferred_server_ssl_mode_disabled_mixed", // RT_ARGCASE_SM_01
757 {
758 {"client_ssl_mode", "preferred"},
759 {"server_ssl_mode", "DisAbled"},
760 {"client_ssl_cert", "some-cert.pem"},
761 {"client_ssl_key", "some-key.pem"},
762 },
763 [](const RoutingPluginConfig &config) {
764 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
765 ASSERT_THAT(config.dest_ssl_mode, SslMode::kDisabled);
766 }},
767 {"client_ssl_mode_preferred_server_ssl_mode_preferred_mixed", // RT_ARGCASE_SM_02
768 {
769 {"client_ssl_mode", "preferred"},
770 {"server_ssl_mode", "PreFerred"},
771 {"client_ssl_cert", "some-cert.pem"},
772 {"client_ssl_key", "some-key.pem"},
773 },
774 [](const RoutingPluginConfig &config) {
775 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
776 ASSERT_THAT(config.dest_ssl_mode, SslMode::kPreferred);
777 }},
778 {"client_ssl_mode_preferred_server_ssl_mode_required_mixed", // RT1_ARGCASE_SM_03
779 {
780 {"client_ssl_mode", "preferred"},
781 {"server_ssl_mode", "Required"},
782 {"client_ssl_cert", "some-cert.pem"},
783 {"client_ssl_key", "some-key.pem"},
784 },
785 [](const RoutingPluginConfig &config) {
786 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
787 ASSERT_THAT(config.dest_ssl_mode, SslMode::kRequired);
788 }},
789
790 {"client_ssl_mode_required", // RT1_MODES_25, RT1_ROUTING_VS_DEFAULT_01
791 {
792 {"client_ssl_mode", "required"},
793 {"client_ssl_cert", "some-cert.pem"},
794 {"client_ssl_key", "some-key.pem"},
795 },
796 [](const RoutingPluginConfig &config) {
797 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
798 }},
799 {"client_ssl_mode_required_mixed_case", // RT1_ARGCASE_CM_03
800 {
801 {"client_ssl_mode", "reQuired"},
802 {"client_ssl_cert", "some-cert.pem"},
803 {"client_ssl_key", "some-key.pem"},
804 },
805 [](const RoutingPluginConfig &config) {
806 ASSERT_EQ(config.source_ssl_mode, SslMode::kRequired);
807 ASSERT_EQ(config.source_ssl_cert, "some-cert.pem");
808 ASSERT_EQ(config.source_ssl_key, "some-key.pem");
809 }},
810 {"client_ssl_mode_required_server_ssl_mode_empty", // RT1_MODES_26
811 {
812 {"client_ssl_mode", "required"},
813 {"server_ssl_mode", ""},
814 {"client_ssl_cert", "some-cert.pem"},
815 {"client_ssl_key", "some-key.pem"},
816 },
817 [](const RoutingPluginConfig &config) {
818 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
819 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
820 }},
821 {"client_ssl_mode_required_server_ssl_mode_disabled", // RT1_MODES_27
822 {
823 {"client_ssl_mode", "required"},
824 {"server_ssl_mode", "disabled"},
825 {"client_ssl_cert", "some-cert.pem"},
826 {"client_ssl_key", "some-key.pem"},
827 },
828 [](const RoutingPluginConfig &config) {
829 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
830 ASSERT_THAT(config.dest_ssl_mode, SslMode::kDisabled);
831 }},
832 {"client_ssl_mode_required_server_ssl_mode_preferred", // RT1_MODES_28
833 {
834 {"client_ssl_mode", "required"},
835 {"server_ssl_mode", "preferred"},
836 {"client_ssl_cert", "some-cert.pem"},
837 {"client_ssl_key", "some-key.pem"},
838 },
839 [](const RoutingPluginConfig &config) {
840 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
841 ASSERT_THAT(config.dest_ssl_mode, SslMode::kPreferred);
842 }},
843 {"client_ssl_mode_required_server_ssl_mode_required", // RT1_MODES_29
844 {
845 {"client_ssl_mode", "required"},
846 {"server_ssl_mode", "required"},
847 {"client_ssl_cert", "some-cert.pem"},
848 {"client_ssl_key", "some-key.pem"},
849 },
850 [](const RoutingPluginConfig &config) {
851 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
852 ASSERT_THAT(config.dest_ssl_mode, SslMode::kRequired);
853 }},
854 {"client_ssl_mode_required_server_ssl_mode_as_client", // RT1_MODES_30
855 {
856 {"client_ssl_mode", "required"},
857 {"server_ssl_mode", "as_client"},
858 {"client_ssl_cert", "some-cert.pem"},
859 {"client_ssl_key", "some-key.pem"},
860 },
861 [](const RoutingPluginConfig &config) {
862 ASSERT_THAT(config.source_ssl_mode, SslMode::kRequired);
863 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
864 }},
865
866 {"client_ssl_mode_passthrough", // RT1_MODES_31
867 {
868 {"client_ssl_mode", "passthrough"},
869 },
870 [](const RoutingPluginConfig &config) {
871 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
872 }},
873 {"client_ssl_mode_passthrough_mixed_case", // RT1_ARGCASE_CM_04
874 {
875 {"client_ssl_mode", "PassThrough"},
876 },
877 [](const RoutingPluginConfig &config) {
878 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
879 }},
880 {"client_ssl_mode_passthrough_server_ssl_mode_empty", // RT1_MODES_32
881 {
882 {"client_ssl_mode", "passthrough"},
883 {"server_ssl_mode", ""},
884 },
885 [](const RoutingPluginConfig &config) {
886 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
887 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
888 }},
889
890 {"client_ssl_mode_passthrough_server_ssl_mode_as_client", // RT1_MODES_36
891 {
892 {"client_ssl_mode", "passthrough"},
893 {"server_ssl_mode", "as_client"},
894 },
895 [](const RoutingPluginConfig &config) {
896 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
897 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
898 }},
899
900 {"client_ssl_key_client_ssl_cert", // RT1_MODES_CERT_KEY_04,
901 // RT1_OPTIONS_PARSE_05
902 // RT1_ROUTING_VS_DEFAULT_?? 08/09
903 {
904 {"client_ssl_cert", "some-cert.pem"},
905 {"client_ssl_key", "some-key.pem"},
906 },
907 [](const RoutingPluginConfig &config) {
908 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
909 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
910
911 ASSERT_EQ(config.source_ssl_cert, "some-cert.pem");
912 ASSERT_EQ(config.source_ssl_key, "some-key.pem");
913 }},
914
915 {"client_ssl_key_empty", // RT1_CERT_KEY_PARSE_02
916 {
917 {"client_ssl_key", ""},
918 },
919 [](const RoutingPluginConfig &config) {
920 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
921 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
922
923 ASSERT_EQ(config.source_ssl_cert, "");
924 ASSERT_EQ(config.source_ssl_key, "");
925 }},
926
927 {"client_ssl_cert_empty", // RT1_CERT_KEY_PARSE_05
928 {
929 {"client_ssl_cert", ""},
930 },
931 [](const RoutingPluginConfig &config) {
932 ASSERT_THAT(config.source_ssl_mode, SslMode::kPassthrough);
933 ASSERT_THAT(config.dest_ssl_mode, SslMode::kAsClient);
934
935 ASSERT_EQ(config.source_ssl_cert, "");
936 ASSERT_EQ(config.source_ssl_key, "");
937 }},
938
939 // server-ssl-verify
940 {"server_ssl_verify_default", // RT1_MODES_VERIFY_01
941 {},
942 [](const RoutingPluginConfig &config) {
943 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kDisabled);
944 }},
945 {"server_ssl_verify_empty", // RT1_MODES_VERIFY_02
946 {
947 {"server_ssl_verify", ""},
948 },
949 [](const RoutingPluginConfig &config) {
950 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kDisabled);
951 }},
952 {"server_ssl_verify_disabled", // RT1_MODES_VERIFY_03
953 {
954 {"server_ssl_verify", "disabled"},
955 },
956 [](const RoutingPluginConfig &config) {
957 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kDisabled);
958 }},
959 {"server_ssl_verify_disabled_mixed_case", // RT1_ARGCASE_SV_01
960 {
961 {"server_ssl_verify", "dIsabled"},
962 },
963 [](const RoutingPluginConfig &config) {
964 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kDisabled);
965 }},
966 {"server_ssl_verify_verify_ca_with_ca_file", // RT1_MODES_VERIFY_04,
967 // RT1_OPTIONS_PARSE_08
968 // RT1_ROUTING_VS_DEFAULT_03
969 // RT1_ROUTING_VS_DEFAULT_11
970 {
971 {"server_ssl_verify", "verify_ca"},
972 {"server_ssl_ca", "some-ca.pem"},
973 },
974 [](const RoutingPluginConfig &config) {
975 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyCa);
976 ASSERT_EQ(config.dest_ssl_ca_file, "some-ca.pem");
977 ASSERT_EQ(config.dest_ssl_ca_dir, "");
978 }},
979 {"server_ssl_verify_verify_ca_with_capath", // RT1_OPTIONS_PARSE_10,
980 // RT1_ROUTING_VS_DEFAULT_13
981 {
982 {"server_ssl_verify", "verify_ca"},
983 {"server_ssl_capath", "some-capath"},
984 },
985 [](const RoutingPluginConfig &config) {
986 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyCa);
987 ASSERT_EQ(config.dest_ssl_ca_file, "");
988 ASSERT_EQ(config.dest_ssl_ca_dir, "some-capath");
989 }},
990 {"server_ssl_verify_verify_ca_mixed_case_with_ca", // RT1_ARGCASE_SV_03
991 {
992 {"server_ssl_verify", "Verify_Ca"},
993 {"server_ssl_ca", "some-ca.pem"},
994 },
995 [](const RoutingPluginConfig &config) {
996 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyCa);
997 ASSERT_EQ(config.dest_ssl_ca_file, "some-ca.pem");
998 ASSERT_EQ(config.dest_ssl_ca_dir, "");
999 }},
1000 {"server_ssl_verify_verify_ca_mixed_case_with_capath",
1001 {
1002 {"server_ssl_verify", "Verify_Ca"},
1003 {"server_ssl_capath", "some-capath"},
1004 },
1005 [](const RoutingPluginConfig &config) {
1006 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyCa);
1007 ASSERT_EQ(config.dest_ssl_ca_file, "");
1008 ASSERT_EQ(config.dest_ssl_ca_dir, "some-capath");
1009 }},
1010 {"server_ssl_verify_verify_identity_with_ca_file", // RT1_MODES_VERIFY_05
1011 {
1012 {"server_ssl_verify", "verify_identity"},
1013 {"server_ssl_ca", "some-ca.pem"},
1014 },
1015 [](const RoutingPluginConfig &config) {
1016 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyIdentity);
1017 ASSERT_EQ(config.dest_ssl_ca_file, "some-ca.pem");
1018 ASSERT_EQ(config.dest_ssl_ca_dir, "");
1019 }},
1020 {"server_ssl_verify_verify_identity_with_capath",
1021 {
1022 {"server_ssl_verify", "verify_identity"},
1023 {"server_ssl_capath", "some-capath"},
1024 },
1025 [](const RoutingPluginConfig &config) {
1026 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyIdentity);
1027 ASSERT_EQ(config.dest_ssl_ca_file, "");
1028 ASSERT_EQ(config.dest_ssl_ca_dir, "some-capath");
1029 }},
1030 {"server_ssl_verify_verify_identity_mixed_case_with_ca", // RT1_ARGCASE_SV_02
1031 {
1032 {"server_ssl_verify", "Verify_Identity"},
1033 {"server_ssl_ca", "some-ca.pem"},
1034 },
1035 [](const RoutingPluginConfig &config) {
1036 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyIdentity);
1037 ASSERT_EQ(config.dest_ssl_ca_file, "some-ca.pem");
1038 ASSERT_EQ(config.dest_ssl_ca_dir, "");
1039 }},
1040 {"server_ssl_verify_verify_identity_mixed_case_with_capath",
1041 {
1042 {"server_ssl_verify", "Verify_Identity"},
1043 {"server_ssl_capath", "some-capath"},
1044 },
1045 [](const RoutingPluginConfig &config) {
1046 ASSERT_EQ(config.dest_ssl_verify, SslVerify::kVerifyIdentity);
1047 ASSERT_EQ(config.dest_ssl_ca_file, "");
1048 ASSERT_EQ(config.dest_ssl_ca_dir, "some-capath");
1049 }},
1050
1051 {"client_ssl_cipher", // RT1_OPTIONS_PARSE_01, RT1_ROUTING_VS_DEFAULT_04
1052 {
1053 {"client_ssl_cipher", "some:val"},
1054 },
1055 [](const RoutingPluginConfig &config) {
1056 ASSERT_EQ(config.source_ssl_cipher, "some:val");
1057 }},
1058 {"server_ssl_cipher", // RT1_OPTIONS_PARSE_02, RT1_ROUTING_VS_DEFAULT_05
1059 {
1060 {"server_ssl_cipher", "some:val"},
1061 },
1062 [](const RoutingPluginConfig &config) {
1063 ASSERT_EQ(config.dest_ssl_cipher, "some:val");
1064 }},
1065 {"client_ssl_curves", // RT1_OPTIONS_PARSE_03, RT1_ROUTING_VS_DEFAULT_06
1066 {
1067 {"client_ssl_curves", "some:val"},
1068 },
1069 [](const RoutingPluginConfig &config) {
1070 ASSERT_EQ(config.source_ssl_curves, "some:val");
1071 }},
1072 {"server_ssl_curves", // RT1_OPTIONS_PARSE_04, RT1_ROUTING_VS_DEFAULT_07
1073 {
1074 {"server_ssl_curves", "some:val"},
1075 },
1076 [](const RoutingPluginConfig &config) {
1077 ASSERT_EQ(config.dest_ssl_curves, "some:val");
1078 }},
1079 {"client_ssl_dh_params", // RT1_OPTIONS_PARSE_07, RT1_ROUTING_VS_DEFAULT_10
1080 {
1081 {"client_ssl_dh_params", "some:val"},
1082 },
1083 [](const RoutingPluginConfig &config) {
1084 ASSERT_EQ(config.source_ssl_dh_params, "some:val");
1085 }},
1086 {"server_ssl_crl", // RT1_OPTIONS_PARSE_09, RT1_ROUTING_VS_DEFAULT_12
1087 {
1088 {"server_ssl_crl", "some:val"},
1089 },
1090 [](const RoutingPluginConfig &config) {
1091 ASSERT_EQ(config.dest_ssl_crl_file, "some:val");
1092 }},
1093 {"server_ssl_crlpath", // RT1_OPTIONS_PARSE_11, RT1_ROUTING_VS_DEFAULT_14
1094 {
1095 {"server_ssl_crlpath", "some:val"},
1096 },
1097 [](const RoutingPluginConfig &config) {
1098 ASSERT_EQ(config.dest_ssl_crl_dir, "some:val");
1099 }},
1100 {"client_ssl_mode_unset_key_cert", // RT1_MODES_CERT_KEY_08
1101 {
1102 {"server_ssl_mode", "disabled"},
1103 {"client_ssl_key", "foo"},
1104 {"client_ssl_cert", "bar"},
1105 },
1106 [](const RoutingPluginConfig &config) {
1107 ASSERT_THAT(config.source_ssl_mode, SslMode::kPreferred);
1108 ASSERT_THAT(config.dest_ssl_mode, SslMode::kDisabled);
1109 }},
1110 };
1111
1112 INSTANTIATE_TEST_SUITE_P(Spec, RoutingConfigTest,
1113 ::testing::ValuesIn(routing_config_params),
1114 [](auto const &info) { return info.param.test_name; });
1115
1116 struct RoutingConfigFailParam {
1117 const char *test_name;
1118
1119 std::vector<std::pair<const char *, const char *>> entries;
1120
1121 std::function<void(const std::exception &)> checker;
1122 };
1123
1124 /**
1125 * check invalid routing config fails.
1126 */
1127 class RoutingConfigFailTest
1128 : public ::testing::Test,
1129 public ::testing::WithParamInterface<RoutingConfigFailParam> {
1130 public:
1131 void SetUp() override {
1132 cfg_.clear();
1133
1134 mysql_harness::ConfigSection &section = cfg_.add("routing", "test_route");
1135 section.add("destinations", "127.0.0.1:3306");
1136 section.add("mode", "read-only");
1137 section.add("bind_port", "6446");
1138 }
1139
1140 protected:
1141 mysql_harness::Config cfg_{mysql_harness::Config::allow_keys};
1142 };
1143
1144 TEST_P(RoutingConfigFailTest, default_option) {
1145 for (auto const &kv : GetParam().entries) {
1146 cfg_.set_default(kv.first, kv.second);
1147 }
1148
1149 mysql_harness::ConfigSection &section = cfg_.get("routing", "test_route");
1150 try {
1151 RoutingPluginConfig config(&section);
1152
1153 FAIL() << "expected to fail";
1154 } catch (const std::exception &e) {
1155 ASSERT_NO_FATAL_FAILURE(GetParam().checker(e));
1156 }
1157 }
1158
1159 TEST_P(RoutingConfigFailTest, section_option) {
1160 mysql_harness::ConfigSection &section = cfg_.get("routing", "test_route");
1161 for (auto const &kv : GetParam().entries) {
1162 section.add(kv.first, kv.second);
1163 }
1164
1165 try {
1166 RoutingPluginConfig config(&section);
1167
1168 FAIL() << "expected to fail";
1169 } catch (const std::exception &e) {
1170 ASSERT_NO_FATAL_FAILURE(GetParam().checker(e));
1171 }
1172 }
1173
1174 const RoutingConfigFailParam routing_config_fail_params[] = {
1175 // server-ssl-mode
1176 //
1177 {"server_ssl_mode_unknown", // RT1_ARGS_BAD_04
1178 {
1179 {"server_ssl_mode", "unknown"},
1180 },
1181 [](const std::exception &e) {
1182 ASSERT_THAT(e.what(),
1183 ::testing::ContainsRegex(
1184 "invalid value 'unknown' for option server_ssl_mode in "
1185 "\\[.+\\]\\. Allowed are: "
1186 "DISABLED,PREFERRED,REQUIRED,AS_CLIENT\\."));
1187 }},
1188 {"server_ssl_mode_quotes", // RT1_ARGS_BAD_05
1189 {
1190 {"server_ssl_mode", "''"},
1191 },
1192 [](const std::exception &e) {
1193 ASSERT_THAT(e.what(),
1194 ::testing::ContainsRegex(
1195 "invalid value '''' for option server_ssl_mode in "
1196 "\\[.+\\]\\. Allowed are: "
1197 "DISABLED,PREFERRED,REQUIRED,AS_CLIENT\\."));
1198 }},
1199 {"server_ssl_mode_quotes_space", // RT1_ARGS_BAD_06
1200 {
1201 {"server_ssl_mode", "' '"},
1202 },
1203 [](const std::exception &e) {
1204 ASSERT_THAT(e.what(),
1205 ::testing::ContainsRegex(
1206 "invalid value '' '' for option server_ssl_mode in "
1207 "\\[.+\\]\\. Allowed are: "
1208 "DISABLED,PREFERRED,REQUIRED,AS_CLIENT\\."));
1209 }},
1210 {"server_ssl_mode_disabled", // RT1_MODES_03, RT1_MODES_CERT_KEY_05
1211 {
1212 {"server_ssl_mode", "disabled"},
1213 },
1214 [](const std::exception &e) {
1215 ASSERT_STREQ(e.what(),
1216 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1217 "be AS_CLIENT.");
1218 }},
1219 {"server_ssl_mode_disabled_mixed_case",
1220 {
1221 {"server_ssl_mode", "DisAbled"},
1222 },
1223 [](const std::exception &e) {
1224 ASSERT_STREQ(e.what(),
1225 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1226 "be AS_CLIENT.");
1227 }},
1228
1229 {"server_ssl_mode_preferred", // RT1_MODES_04
1230 {
1231 {"server_ssl_mode", "preferred"},
1232 },
1233 [](const std::exception &e) {
1234 ASSERT_STREQ(e.what(),
1235 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1236 "be AS_CLIENT.");
1237 }},
1238 {"server_ssl_mode_preferred_mixed_case",
1239 {
1240 {"server_ssl_mode", "PreferreD"},
1241 },
1242 [](const std::exception &e) {
1243 ASSERT_STREQ(e.what(),
1244 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1245 "be AS_CLIENT.");
1246 }},
1247 {"server_ssl_mode_required", // RT1_MODES_05
1248 {
1249 {"server_ssl_mode", "required"},
1250 },
1251 [](const std::exception &e) {
1252 ASSERT_STREQ(e.what(),
1253 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1254 "be AS_CLIENT.");
1255 }},
1256 {"server_ssl_mode_required_mixed_case",
1257 {
1258 {"server_ssl_mode", "reQuired"},
1259 },
1260 [](const std::exception &e) {
1261 ASSERT_STREQ(e.what(),
1262 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1263 "be AS_CLIENT.");
1264 }},
1265 {"client_ssl_mode_empty_server_ssl_mode_disabled", // RT1_MODES_09
1266 {
1267 {"client_ssl_mode", ""},
1268 {"server_ssl_mode", "disabled"},
1269 },
1270 [](const std::exception &e) {
1271 ASSERT_STREQ(e.what(),
1272 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1273 "be AS_CLIENT.");
1274 }},
1275 {"client_ssl_mode_empty_server_ssl_mode_preferred", // RT1_MODES_10
1276 {
1277 {"client_ssl_mode", ""},
1278 {"server_ssl_mode", "preferred"},
1279 },
1280 [](const std::exception &e) {
1281 ASSERT_STREQ(e.what(),
1282 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1283 "be AS_CLIENT.");
1284 }},
1285 {"client_ssl_mode_empty_server_ssl_mode_required", // RT1_MODES_11
1286 {
1287 {"client_ssl_mode", ""},
1288 {"server_ssl_mode", "required"},
1289 },
1290 [](const std::exception &e) {
1291 ASSERT_STREQ(e.what(),
1292 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1293 "be AS_CLIENT.");
1294 }},
1295 {"client_ssl_mode_passthrough_server_ssl_mode_disabled", // RT1_MODES_33,
1296 // RT2_CONN_TYPE_RSLN_00_13
1297 // RT2_CONN_TYPE_RSLN_01_13
1298 // RT2_CONN_TYPE_RSLN_10_13
1299 // RT2_CONN_TYPE_RSLN_11_13
1300 {
1301 {"client_ssl_mode", "passthrough"},
1302 {"server_ssl_mode", "disabled"},
1303 },
1304 [](const std::exception &e) {
1305 ASSERT_STREQ(e.what(),
1306 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1307 "be AS_CLIENT.");
1308 }},
1309 {"client_ssl_mode_passthrough_server_ssl_mode_preferred", // RT1_MODES_34,
1310 // RT2_CONN_TYPE_RSLN_00_14
1311 // RT2_CONN_TYPE_RSLN_01_14
1312 // RT2_CONN_TYPE_RSLN_10_14
1313 // RT2_CONN_TYPE_RSLN_11_14
1314 {
1315 {"client_ssl_mode", "passthrough"},
1316 {"server_ssl_mode", "preferred"},
1317 },
1318 [](const std::exception &e) {
1319 ASSERT_STREQ(e.what(),
1320 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1321 "be AS_CLIENT.");
1322 }},
1323 {"client_ssl_mode_passthrough_server_ssl_mode_required", // RT1_MODES_35,
1324 // RT2_CONN_TYPE_RSLN_00_15
1325 // RT2_CONN_TYPE_RSLN_01_15
1326 // RT2_CONN_TYPE_RSLN_10_15
1327 // RT2_CONN_TYPE_RSLN_11_15
1328
1329 {
1330 {"client_ssl_mode", "passthrough"},
1331 {"server_ssl_mode", "required"},
1332 },
1333 [](const std::exception &e) {
1334 ASSERT_STREQ(e.what(),
1335 "If client_ssl_mode is PASSTHROUGH, server_ssl_mode must "
1336 "be AS_CLIENT.");
1337 }},
1338
1339 // client-ssl-mode
1340 //
1341 {"client_ssl_mode_unknown", // RT1_ARGS_BAD_01
1342 {
1343 {"client_ssl_mode", "unknown"},
1344 },
1345 [](const std::exception &e) {
1346 ASSERT_THAT(e.what(),
1347 ::testing::ContainsRegex(
1348 "invalid value 'unknown' for option client_ssl_mode in "
1349 "\\[.+\\]\\. Allowed are: "
1350 "DISABLED,PREFERRED,REQUIRED,PASSTHROUGH\\."));
1351 }},
1352 {"client_ssl_mode_quotes", // RT1_ARGS_BAD_02
1353 {
1354 {"client_ssl_mode", "''"},
1355 },
1356 [](const std::exception &e) {
1357 ASSERT_THAT(e.what(),
1358 ::testing::ContainsRegex(
1359 "invalid value '''' for option client_ssl_mode in "
1360 "\\[.+\\]\\. Allowed are: "
1361 "DISABLED,PREFERRED,REQUIRED,PASSTHROUGH\\."));
1362 }},
1363 {"client_ssl_mode_quotes_space", // RT1_ARGS_BAD_03
1364 {
1365 {"client_ssl_mode", "' '"},
1366 },
1367 [](const std::exception &e) {
1368 ASSERT_THAT(e.what(),
1369 ::testing::ContainsRegex(
1370 "invalid value '' '' for option client_ssl_mode in "
1371 "\\[.+\\]\\. Allowed are: "
1372 "DISABLED,PREFERRED,REQUIRED,PASSTHROUGH\\."));
1373 }},
1374 {"client_ssl_mode_preferred_missing_cert",
1375 {
1376 {"client_ssl_mode", "preferred"},
1377 },
1378 [](const std::exception &e) {
1379 ASSERT_STREQ(
1380 e.what(),
1381 "client_ssl_cert must be set, if client_ssl_mode is 'PREFERRED'.");
1382 }},
1383 {"client_ssl_mode_required_missing_cert",
1384 {
1385 {"client_ssl_mode", "required"},
1386 },
1387 [](const std::exception &e) {
1388 ASSERT_STREQ(
1389 e.what(),
1390 "client_ssl_cert must be set, if client_ssl_mode is 'REQUIRED'.");
1391 }},
1392 {"client_ssl_mode_preferred_missing_key",
1393 {
1394 {"client_ssl_mode", "preferred"},
1395 {"client_ssl_cert", "some-cert.pem"},
1396 },
1397 [](const std::exception &e) {
1398 ASSERT_STREQ(
1399 e.what(),
1400 "client_ssl_key must be set, if client_ssl_mode is 'PREFERRED'.");
1401 }},
1402 {"client_ssl_mode_required_missing_key",
1403 {
1404 {"client_ssl_mode", "required"},
1405 {"client_ssl_cert", "some-cert.pem"},
1406 },
1407 [](const std::exception &e) {
1408 ASSERT_STREQ(
1409 e.what(),
1410 "client_ssl_key must be set, if client_ssl_mode is 'REQUIRED'.");
1411 }},
1412
1413 // server-ssl-verify
1414 {"server_ssl_verify_unknown", // RT1_ARGS_BAD_07
1415 {
1416 {"server_ssl_verify", "unknown"},
1417 },
1418 [](const std::exception &e) {
1419 ASSERT_THAT(
1420 e.what(),
1421 ::testing::ContainsRegex(
1422 "invalid value 'unknown' for option server_ssl_verify in "
1423 "\\[.+\\]\\. Allowed are: "
1424 "DISABLED,VERIFY_CA,VERIFY_IDENTITY\\."));
1425 }},
1426 {"server_ssl_verify_quotes", // RT1_ARGS_BAD_08
1427 {
1428 {"server_ssl_verify", "''"},
1429 },
1430 [](const std::exception &e) {
1431 ASSERT_THAT(e.what(),
1432 ::testing::ContainsRegex(
1433 "invalid value '''' for option server_ssl_verify in "
1434 "\\[.+\\]\\. Allowed are: "
1435 "DISABLED,VERIFY_CA,VERIFY_IDENTITY\\."));
1436 }},
1437 {"server_ssl_verify_quotes_space", // RT1_ARGS_BAD_09
1438 {
1439 {"server_ssl_verify", "' '"},
1440 },
1441 [](const std::exception &e) {
1442 ASSERT_THAT(e.what(),
1443 ::testing::ContainsRegex(
1444 "invalid value '' '' for option server_ssl_verify in "
1445 "\\[.+\\]\\. Allowed are: "
1446 "DISABLED,VERIFY_CA,VERIFY_IDENTITY\\."));
1447 }},
1448 {"server_ssl_verify_verify_ca_missing_ca",
1449 {
1450 {"server_ssl_verify", "verify_ca"},
1451 },
1452 [](const std::exception &e) {
1453 ASSERT_STREQ(e.what(),
1454 "server_ssl_ca or server_ssl_capath must be set, if "
1455 "server_ssl_verify is 'VERIFY_CA'.");
1456 }},
1457 {"server_ssl_verify_verify_identity_missing_ca",
1458 {
1459 {"server_ssl_verify", "verify_identity"},
1460 },
1461 [](const std::exception &e) {
1462 ASSERT_STREQ(e.what(),
1463 "server_ssl_ca or server_ssl_capath must be set, if "
1464 "server_ssl_verify is 'VERIFY_IDENTITY'.");
1465 }},
1466 {"client_ssl_key_without_ssl_cert", // RT1_MODES_CERT_KEY_02,
1467 // RT1_CERT_KEY_PARSE_01
1468 {
1469 {"client_ssl_key", "some-key"},
1470 },
1471 [](const std::exception &e) {
1472 ASSERT_STREQ(
1473 e.what(),
1474 // setting client-ssl-key switches to client-ssl-mode to PREFERRED.
1475 "client_ssl_cert must be set, if client_ssl_mode is 'PREFERRED'.");
1476 }},
1477 {"client_ssl_cert_without_ssl_key", // RT1_MODES_CERT_KEY_03,
1478 // RT1_CERT_KEY_PARSE_04
1479 {
1480 {"client_ssl_cert", "some-cert"},
1481 },
1482 [](const std::exception &e) {
1483 ASSERT_STREQ(
1484 e.what(),
1485 // setting client-ssl-key switches to client-ssl-mode to PREFERRED.
1486 "client_ssl_key must be set, if client_ssl_mode is 'PREFERRED'.");
1487 }},
1488 {"client_ssl_key_without_ssl_cert_server_ssl_mode_disabled", // RT1_MODES_CERT_KEY_06
1489 {
1490 {"server_ssl_mode", "disabled"},
1491 {"client_ssl_key", "some-key"},
1492 },
1493 [](const std::exception &e) {
1494 ASSERT_STREQ(
1495 e.what(),
1496 // setting client-ssl-key switches to client-ssl-mode to PREFERRED.
1497 "client_ssl_cert must be set, if client_ssl_mode is 'PREFERRED'.");
1498 }},
1499 {"client_ssl_cert_without_ssl_key_server_ssl_mode_disabled", // RT1_MODES_CERT_KEY_07
1500 {
1501 {"server_ssl_mode", "disabled"},
1502 {"client_ssl_cert", "some-cert"},
1503 },
1504 [](const std::exception &e) {
1505 ASSERT_STREQ(
1506 e.what(),
1507 // setting client-ssl-key switches to client-ssl-mode to PREFERRED.
1508 "client_ssl_key must be set, if client_ssl_mode is 'PREFERRED'.");
1509 }},
1510 };
1511
1512 INSTANTIATE_TEST_SUITE_P(Fail, RoutingConfigFailTest,
1513 ::testing::ValuesIn(routing_config_fail_params),
1514 [](auto const &info) { return info.param.test_name; });
1515
1516 int main(int argc, char *argv[]) {
1517 init_test_logger();
1518 init_windows_sockets();
1519 g_origin = Path(argv[0]).dirname();
1520 g_cwd = Path(argv[0]).dirname().str();
1521 ::testing::InitGoogleTest(&argc, argv);
1522 return RUN_ALL_TESTS();
1523 }