[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 <arpa/nameser_compat.h>

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