| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "osp/impl/testing/fake_mdns_responder_adapter.h" |
| |
| #include "gtest/gtest.h" |
| |
| namespace openscreen { |
| namespace osp { |
| |
| namespace { |
| |
| constexpr char kTestServiceInstance[] = "turtle"; |
| constexpr char kTestServiceName[] = "_foo"; |
| constexpr char kTestServiceProtocol[] = "_udp"; |
| |
| UdpSocket* const kDefaultSocket = |
| reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(8)); |
| UdpSocket* const kSecondSocket = |
| reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(32)); |
| |
| } // namespace |
| |
| TEST(FakeMdnsResponderAdapterTest, AQueries) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| auto event = MakeAEvent("alpha", IPAddress{1, 2, 3, 4}, kDefaultSocket); |
| auto domain_name = event.domain_name; |
| mdns_responder.AddAEvent(std::move(event)); |
| |
| auto a_events = mdns_responder.TakeAResponses(); |
| EXPECT_TRUE(a_events.empty()); |
| |
| auto result = mdns_responder.StartAQuery(kDefaultSocket, domain_name); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| a_events = mdns_responder.TakeAResponses(); |
| ASSERT_EQ(1u, a_events.size()); |
| EXPECT_EQ(domain_name, a_events[0].domain_name); |
| EXPECT_EQ((IPAddress{1, 2, 3, 4}), a_events[0].address); |
| |
| result = mdns_responder.StopAQuery(kDefaultSocket, domain_name); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| |
| mdns_responder.AddAEvent( |
| MakeAEvent("alpha", IPAddress{1, 2, 3, 4}, kDefaultSocket)); |
| result = mdns_responder.StartAQuery(kDefaultSocket, domain_name); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| a_events = mdns_responder.TakeAResponses(); |
| EXPECT_TRUE(a_events.empty()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, AaaaQueries) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| auto event = MakeAaaaEvent("alpha", IPAddress{1, 2, 3, 4}, kDefaultSocket); |
| auto domain_name = event.domain_name; |
| mdns_responder.AddAaaaEvent(std::move(event)); |
| |
| auto aaaa_events = mdns_responder.TakeAaaaResponses(); |
| EXPECT_TRUE(aaaa_events.empty()); |
| |
| auto result = mdns_responder.StartAaaaQuery(kDefaultSocket, domain_name); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| aaaa_events = mdns_responder.TakeAaaaResponses(); |
| ASSERT_EQ(1u, aaaa_events.size()); |
| EXPECT_EQ(domain_name, aaaa_events[0].domain_name); |
| EXPECT_EQ((IPAddress{1, 2, 3, 4}), aaaa_events[0].address); |
| |
| result = mdns_responder.StopAaaaQuery(kDefaultSocket, domain_name); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| |
| mdns_responder.AddAaaaEvent( |
| MakeAaaaEvent("alpha", IPAddress{1, 2, 3, 4}, kDefaultSocket)); |
| result = mdns_responder.StartAaaaQuery(kDefaultSocket, domain_name); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| aaaa_events = mdns_responder.TakeAaaaResponses(); |
| EXPECT_TRUE(aaaa_events.empty()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, PtrQueries) { |
| const DomainName kTestServiceType{ |
| {4, '_', 'f', 'o', 'o', 4, '_', 'u', 'd', 'p', 0}}; |
| const DomainName kTestServiceTypeCanon{{4, '_', 'f', 'o', 'o', 4, '_', 'u', |
| 'd', 'p', 5, 'l', 'o', 'c', 'a', 'l', |
| 0}}; |
| |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| mdns_responder.AddPtrEvent( |
| MakePtrEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| kDefaultSocket)); |
| |
| auto ptr_events = mdns_responder.TakePtrResponses(); |
| EXPECT_TRUE(ptr_events.empty()); |
| |
| auto result = mdns_responder.StartPtrQuery(kDefaultSocket, kTestServiceType); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| ptr_events = mdns_responder.TakePtrResponses(); |
| ASSERT_EQ(1u, ptr_events.size()); |
| auto labels = ptr_events[0].service_instance.GetLabels(); |
| EXPECT_EQ(kTestServiceInstance, labels[0]); |
| |
| // TODO(btolsch): qname if PtrEvent gets it. |
| ErrorOr<DomainName> st = |
| DomainName::FromLabels(labels.begin() + 1, labels.end()); |
| ASSERT_TRUE(st); |
| EXPECT_EQ(kTestServiceTypeCanon, st.value()); |
| |
| result = mdns_responder.StopPtrQuery(kDefaultSocket, kTestServiceType); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| |
| mdns_responder.AddPtrEvent( |
| MakePtrEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| kDefaultSocket)); |
| result = mdns_responder.StartPtrQuery(kDefaultSocket, kTestServiceType); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| ptr_events = mdns_responder.TakePtrResponses(); |
| EXPECT_TRUE(ptr_events.empty()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, SrvQueries) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| |
| auto event = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "alpha", 12345, kDefaultSocket); |
| auto service_instance = event.service_instance; |
| auto domain_name = event.domain_name; |
| mdns_responder.AddSrvEvent(std::move(event)); |
| |
| auto srv_events = mdns_responder.TakeSrvResponses(); |
| EXPECT_TRUE(srv_events.empty()); |
| |
| auto result = mdns_responder.StartSrvQuery(kDefaultSocket, service_instance); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| srv_events = mdns_responder.TakeSrvResponses(); |
| ASSERT_EQ(1u, srv_events.size()); |
| EXPECT_EQ(service_instance, srv_events[0].service_instance); |
| EXPECT_EQ(domain_name, srv_events[0].domain_name); |
| EXPECT_EQ(12345, srv_events[0].port); |
| |
| result = mdns_responder.StopSrvQuery(kDefaultSocket, service_instance); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| |
| mdns_responder.AddSrvEvent( |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "alpha", 12345, kDefaultSocket)); |
| result = mdns_responder.StartSrvQuery(kDefaultSocket, service_instance); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| srv_events = mdns_responder.TakeSrvResponses(); |
| EXPECT_TRUE(srv_events.empty()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, TxtQueries) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| |
| const auto txt_lines = std::vector<std::string>{"asdf", "jkl;", "j"}; |
| auto event = MakeTxtEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, txt_lines, kDefaultSocket); |
| auto service_instance = event.service_instance; |
| mdns_responder.AddTxtEvent(std::move(event)); |
| |
| auto txt_events = mdns_responder.TakeTxtResponses(); |
| EXPECT_TRUE(txt_events.empty()); |
| |
| auto result = mdns_responder.StartTxtQuery(kDefaultSocket, service_instance); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| txt_events = mdns_responder.TakeTxtResponses(); |
| ASSERT_EQ(1u, txt_events.size()); |
| EXPECT_EQ(service_instance, txt_events[0].service_instance); |
| EXPECT_EQ(txt_lines, txt_events[0].txt_info); |
| |
| result = mdns_responder.StopTxtQuery(kDefaultSocket, service_instance); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| |
| mdns_responder.AddTxtEvent( |
| MakeTxtEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| txt_lines, kDefaultSocket)); |
| result = mdns_responder.StartTxtQuery(kDefaultSocket, service_instance); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| txt_events = mdns_responder.TakeTxtResponses(); |
| EXPECT_TRUE(txt_events.empty()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, RegisterServices) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| |
| auto result = mdns_responder.RegisterService( |
| "instance", "name", "proto", |
| DomainName{{1, 'a', 5, 'l', 'o', 'c', 'a', 'l', 0}}, 12345, |
| {{"k1", "asdf"}, {"k2", "jkl"}}); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| EXPECT_EQ(1u, mdns_responder.registered_services().size()); |
| |
| result = mdns_responder.RegisterService( |
| "instance2", "name", "proto", |
| DomainName{{1, 'b', 5, 'l', 'o', 'c', 'a', 'l', 0}}, 12346, |
| {{"k1", "asdf"}, {"k2", "jkl"}}); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| EXPECT_EQ(2u, mdns_responder.registered_services().size()); |
| |
| result = mdns_responder.DeregisterService("instance", "name", "proto"); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| result = mdns_responder.DeregisterService("instance", "name", "proto"); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| EXPECT_EQ(1u, mdns_responder.registered_services().size()); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| EXPECT_EQ(0u, mdns_responder.registered_services().size()); |
| |
| result = mdns_responder.RegisterService( |
| "instance2", "name", "proto", |
| DomainName{{1, 'b', 5, 'l', 'o', 'c', 'a', 'l', 0}}, 12346, |
| {{"k1", "asdf"}, {"k2", "jkl"}}); |
| EXPECT_NE(MdnsResponderErrorCode::kNoError, result); |
| EXPECT_EQ(0u, mdns_responder.registered_services().size()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, RegisterInterfaces) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); |
| |
| Error result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, |
| kDefaultSocket); |
| EXPECT_TRUE(result.ok()); |
| EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); |
| |
| result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, |
| kDefaultSocket); |
| EXPECT_FALSE(result.ok()); |
| EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); |
| |
| result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, |
| kSecondSocket); |
| EXPECT_TRUE(result.ok()); |
| EXPECT_EQ(2u, mdns_responder.registered_interfaces().size()); |
| |
| result = mdns_responder.DeregisterInterface(kSecondSocket); |
| EXPECT_TRUE(result.ok()); |
| EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); |
| result = mdns_responder.DeregisterInterface(kSecondSocket); |
| EXPECT_FALSE(result.ok()); |
| EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); |
| |
| mdns_responder.Close(); |
| ASSERT_FALSE(mdns_responder.running()); |
| EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); |
| |
| result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, |
| kDefaultSocket); |
| EXPECT_FALSE(result.ok()); |
| EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); |
| } |
| |
| TEST(FakeMdnsResponderAdapterTest, UpdateTxtData) { |
| FakeMdnsResponderAdapter mdns_responder; |
| |
| mdns_responder.Init(); |
| ASSERT_TRUE(mdns_responder.running()); |
| |
| const std::map<std::string, std::string> txt_data1{{"k1", "asdf"}, |
| {"k2", "jkl"}}; |
| auto result = mdns_responder.RegisterService( |
| "instance", "name", "proto", |
| DomainName{{1, 'a', 5, 'l', 'o', 'c', 'a', 'l', 0}}, 12345, txt_data1); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| ASSERT_EQ(1u, mdns_responder.registered_services().size()); |
| EXPECT_EQ(txt_data1, mdns_responder.registered_services()[0].txt_data); |
| |
| const std::map<std::string, std::string> txt_data2{ |
| {"k1", "monkey"}, {"k2", "panda"}, {"k3", "turtle"}, {"k4", "rhino"}}; |
| result = mdns_responder.UpdateTxtData("instance", "name", "proto", txt_data2); |
| EXPECT_EQ(MdnsResponderErrorCode::kNoError, result); |
| ASSERT_EQ(1u, mdns_responder.registered_services().size()); |
| EXPECT_EQ(txt_data2, mdns_responder.registered_services()[0].txt_data); |
| } |
| |
| } // namespace osp |
| } // namespace openscreen |