[ceph.git] / ceph / src / test / common / dns_resolve.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2016 SUSE LINUX GmbH
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software
 * Foundation.  See file COPYING.
 *
 */
#include "common/dns_resolve.h"
#include "test/common/dns_messages.h"

#include "common/debug.h"
#include "gmock/gmock.h"


#include <sstream>

#define TEST_DEBUG 20

#define dout_subsys ceph_subsys_


using ::testing::Return;
using ::testing::_;
using ::testing::SetArrayArgument;
using ::testing::DoAll;
using ::testing::StrEq;

class DNSResolverTest : public ::testing::Test {
  protected:
    void SetUp() override {
      g_ceph_context->_conf->subsys.set_log_level(dout_subsys, TEST_DEBUG);
    }

    void TearDown() override  {
      DNSResolver::get_instance(nullptr);
    }
};

TEST_F(DNSResolverTest, resolve_ip_addr) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();

  int lena = sizeof(ns_query_msg_mon_a_payload);
#ifdef HAVE_RES_NQUERY
  EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));
#else
  EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));
#endif

  entity_addr_t addr;
  DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context,
      "mon.a.ceph.com", &addr);

  std::ostringstream os;
  os << addr;
  ASSERT_EQ(os.str(), "192.168.1.11:0/0");
}

TEST_F(DNSResolverTest, resolve_ip_addr_fail) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();

#ifdef HAVE_RES_NQUERY
  EXPECT_CALL(*resolvH, res_nquery(_,StrEq("not_exists.com"), C_IN, T_A,_,_))
       .WillOnce(Return(0));
#else
  EXPECT_CALL(*resolvH, res_query(StrEq("not_exists.com"), C_IN, T_A,_,_))
       .WillOnce(Return(0));
#endif

  entity_addr_t addr;
  int ret = DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context, 
      "not_exists.com", &addr);

  ASSERT_EQ(ret, -1);
  std::ostringstream os;
  os << addr;
  ASSERT_EQ(os.str(), "-");
}


TEST_F(DNSResolverTest, resolve_srv_hosts_empty_domain) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();


  int len = sizeof(ns_search_msg_ok_payload);
  int lena = sizeof(ns_query_msg_mon_a_payload);
  int lenb = sizeof(ns_query_msg_mon_b_payload);
  int lenc = sizeof(ns_query_msg_mon_c_payload);

  using ::testing::InSequence;
  {
    InSequence s;

#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#endif
  }

  map<string, DNSResolver::Record> records;
  DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon", 
      DNSResolver::SRV_Protocol::TCP, &records);

  ASSERT_EQ(records.size(), (unsigned int)3);
  auto it = records.find("mon.a");
  ASSERT_NE(it, records.end());
  std::ostringstream os;
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
  os.str("");
  it = records.find("mon.b");
  ASSERT_NE(it, records.end());
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
  os.str("");
  it = records.find("mon.c");
  ASSERT_NE(it, records.end());
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
}

TEST_F(DNSResolverTest, resolve_srv_hosts_full_domain) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();


  int len = sizeof(ns_search_msg_ok_payload);
  int lena = sizeof(ns_query_msg_mon_a_payload);
  int lenb = sizeof(ns_query_msg_mon_b_payload);
  int lenc = sizeof(ns_query_msg_mon_c_payload);

  using ::testing::InSequence;
  {
    InSequence s;

#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#endif
  }

  map<string, DNSResolver::Record> records;
  DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon", 
      DNSResolver::SRV_Protocol::TCP, "ceph.com", &records);

  ASSERT_EQ(records.size(), (unsigned int)3);
  auto it = records.find("mon.a");
  ASSERT_NE(it, records.end());
  std::ostringstream os;
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
  os.str("");
  it = records.find("mon.b");
  ASSERT_NE(it, records.end());
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
  os.str("");
  it = records.find("mon.c");
  ASSERT_NE(it, records.end());
  os << it->second.addr;
  ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
}

TEST_F(DNSResolverTest, resolve_srv_hosts_fail) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();


  using ::testing::InSequence;
  {
    InSequence s;

#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(Return(0));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(Return(0));
#endif
  }

  map<string, DNSResolver::Record> records;
  int ret = DNSResolver::get_instance(resolvH)->resolve_srv_hosts(
      g_ceph_context, "noservice", DNSResolver::SRV_Protocol::TCP, "", &records);

  ASSERT_EQ(0, ret);
  ASSERT_TRUE(records.empty());
}
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3	/*
	4	* Ceph - scalable distributed file system
	5	*
	6	* Copyright (C) 2016 SUSE LINUX GmbH
	7	*
	8	* This is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License version 2.1, as published by the Free Software
	11	* Foundation. See file COPYING.
	12	*
	13	*/
	14	#include "common/dns_resolve.h"
	15	#include "test/common/dns_messages.h"
	16
	17	#include "common/debug.h"
	18	#include "gmock/gmock.h"
	19
	20
	21	#include <sstream>
	22
	23	#define TEST_DEBUG 20
	24
	25	#define dout_subsys ceph_subsys_
	26
	27
	28	using ::testing::Return;
	29	using ::testing::_;
	30	using ::testing::SetArrayArgument;
	31	using ::testing::DoAll;
	32	using ::testing::StrEq;
	33
	34	class DNSResolverTest : public ::testing::Test {
	35	protected:
	36	void SetUp() override {
	37	g_ceph_context->_conf->subsys.set_log_level(dout_subsys, TEST_DEBUG);
	38	}
	39
	40	void TearDown() override {
	41	DNSResolver::get_instance(nullptr);
	42	}
	43	};
	44
	45	TEST_F(DNSResolverTest, resolve_ip_addr) {
	46	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	47
	48	int lena = sizeof(ns_query_msg_mon_a_payload);
	49	#ifdef HAVE_RES_NQUERY
	50	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	51	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
	52	ns_query_msg_mon_a_payload+lena), Return(lena)));
	53	#else
	54	EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	55	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
	56	ns_query_msg_mon_a_payload+lena), Return(lena)));
	57	#endif
	58
	59	entity_addr_t addr;
	60	DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context,
	61	"mon.a.ceph.com", &addr);
	62
	63	std::ostringstream os;
	64	os << addr;
65	ASSERT_EQ(os.str(), "192.168.1.11:0/0");
66	}
67
68	TEST_F(DNSResolverTest, resolve_ip_addr_fail) {
69	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
70
71	#ifdef HAVE_RES_NQUERY
72	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("not_exists.com"), C_IN, T_A,_,_))
73	.WillOnce(Return(0));
74	#else
75	EXPECT_CALL(*resolvH, res_query(StrEq("not_exists.com"), C_IN, T_A,_,_))
76	.WillOnce(Return(0));
77	#endif
78
79	entity_addr_t addr;
80	int ret = DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context,
81	"not_exists.com", &addr);
82
83	ASSERT_EQ(ret, -1);
84	std::ostringstream os;
85	os << addr;
86	ASSERT_EQ(os.str(), "-");
87	}
88
89
90	TEST_F(DNSResolverTest, resolve_srv_hosts_empty_domain) {
91	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
92
93
94	int len = sizeof(ns_search_msg_ok_payload);
95	int lena = sizeof(ns_query_msg_mon_a_payload);
96	int lenb = sizeof(ns_query_msg_mon_b_payload);
97	int lenc = sizeof(ns_query_msg_mon_c_payload);
98
99	using ::testing::InSequence;
100	{
101	InSequence s;
102
103	#ifdef HAVE_RES_NQUERY
104	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
105	.WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
106	ns_search_msg_ok_payload+len), Return(len)));
107
108	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
109	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
110	ns_query_msg_mon_a_payload+lena), Return(lena)));
111
112	EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
113	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
114	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
115
116	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
117	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
118	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
119	#else
120	EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
121	.WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
122	ns_search_msg_ok_payload+len), Return(len)));
123
124	EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
125	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
126	ns_query_msg_mon_a_payload+lena), Return(lena)));
127
128	EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
129	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
130	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
131
132	EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
133	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
134	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
135	#endif
136	}
137
224ce89b	138	map<string, DNSResolver::Record> records;
7c673cae	139	DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon",
224ce89b	140	DNSResolver::SRV_Protocol::TCP, &records);
7c673cae	141
224ce89b WB	142	ASSERT_EQ(records.size(), (unsigned int)3);
	143	auto it = records.find("mon.a");
	144	ASSERT_NE(it, records.end());
7c673cae	145	std::ostringstream os;
224ce89b	146	os << it->second.addr;
7c673cae FG	147	ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
7c673cae FG	148	os.str("");
224ce89b WB	149	it = records.find("mon.b");
	150	ASSERT_NE(it, records.end());
	151	os << it->second.addr;
7c673cae FG	152	ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
7c673cae FG	153	os.str("");
224ce89b WB	154	it = records.find("mon.c");
	155	ASSERT_NE(it, records.end());
	156	os << it->second.addr;
7c673cae FG	157	ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
	158	}
	159
	160	TEST_F(DNSResolverTest, resolve_srv_hosts_full_domain) {
	161	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	162
	163
	164	int len = sizeof(ns_search_msg_ok_payload);
	165	int lena = sizeof(ns_query_msg_mon_a_payload);
	166	int lenb = sizeof(ns_query_msg_mon_b_payload);
	167	int lenc = sizeof(ns_query_msg_mon_c_payload);
	168
	169	using ::testing::InSequence;
	170	{
	171	InSequence s;
	172
	173	#ifdef HAVE_RES_NQUERY
	174	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
	175	.WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
	176	ns_search_msg_ok_payload+len), Return(len)));
	177
	178	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	179	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
	180	ns_query_msg_mon_a_payload+lena), Return(lena)));
	181
	182	EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	183	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
	184	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	185
	186	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	187	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
	188	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	189	#else
	190	EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
	191	.WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
	192	ns_search_msg_ok_payload+len), Return(len)));
	193
	194	EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	195	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
	196	ns_query_msg_mon_a_payload+lena), Return(lena)));
	197
	198	EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	199	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
	200	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	201
	202	EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	203	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
	204	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	205	#endif
	206	}
	207
224ce89b	208	map<string, DNSResolver::Record> records;
7c673cae	209	DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon",
224ce89b	210	DNSResolver::SRV_Protocol::TCP, "ceph.com", &records);
7c673cae	211
224ce89b WB	212	ASSERT_EQ(records.size(), (unsigned int)3);
	213	auto it = records.find("mon.a");
	214	ASSERT_NE(it, records.end());
7c673cae	215	std::ostringstream os;
224ce89b	216	os << it->second.addr;
7c673cae FG	217	ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
7c673cae FG	218	os.str("");
224ce89b WB	219	it = records.find("mon.b");
	220	ASSERT_NE(it, records.end());
	221	os << it->second.addr;
7c673cae FG	222	ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
7c673cae FG	223	os.str("");
224ce89b WB	224	it = records.find("mon.c");
	225	ASSERT_NE(it, records.end());
	226	os << it->second.addr;
7c673cae FG	227	ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
	228	}
	229
	230	TEST_F(DNSResolverTest, resolve_srv_hosts_fail) {
	231	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	232
	233
	234	using ::testing::InSequence;
	235	{
	236	InSequence s;
	237
	238	#ifdef HAVE_RES_NQUERY
	239	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
	240	.WillOnce(Return(0));
	241	#else
	242	EXPECT_CALL(*resolvH, res_search(StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
	243	.WillOnce(Return(0));
	244	#endif
	245	}
	246
224ce89b	247	map<string, DNSResolver::Record> records;
7c673cae	248	int ret = DNSResolver::get_instance(resolvH)->resolve_srv_hosts(
224ce89b	249	g_ceph_context, "noservice", DNSResolver::SRV_Protocol::TCP, "", &records);
7c673cae	250
224ce89b WB	251	ASSERT_EQ(0, ret);
224ce89b WB	252	ASSERT_TRUE(records.empty());
7c673cae FG	253	}
7c673cae FG	254