| // 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/mdns_responder_service.h" |
| |
| #include <cstdint> |
| #include <iostream> |
| #include <memory> |
| #include <utility> |
| |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include "osp/impl/service_listener_impl.h" |
| #include "osp/impl/testing/fake_mdns_platform_service.h" |
| #include "osp/impl/testing/fake_mdns_responder_adapter.h" |
| #include "platform/test/fake_task_runner.h" |
| |
| namespace openscreen { |
| namespace osp { |
| |
| // Child of the MdnsResponderService for testing purposes. Only difference |
| // betweeen this and the base class is that methods on this class are executed |
| // synchronously, rather than pushed to the task runner for later execution. |
| class TestingMdnsResponderService final : public MdnsResponderService { |
| public: |
| TestingMdnsResponderService( |
| FakeTaskRunner* task_runner, |
| const std::string& service_name, |
| const std::string& service_protocol, |
| std::unique_ptr<MdnsResponderAdapterFactory> mdns_responder_factory, |
| std::unique_ptr<MdnsPlatformService> platform_service) |
| : MdnsResponderService(&FakeClock::now, |
| task_runner, |
| service_name, |
| service_protocol, |
| std::move(mdns_responder_factory), |
| std::move(platform_service)) {} |
| ~TestingMdnsResponderService() = default; |
| |
| // Override the default ServiceListenerImpl and ServicePublisherImpl |
| // implementations. These call the internal implementations of each of the |
| // methods provided, meaning that the end result of the call is the same, but |
| // without pushing to the task runner and waiting for it to be pulled off |
| // again. |
| // ServiceListenerImpl::Delegate overrides. |
| void StartListener() override { StartListenerInternal(); } |
| void StartAndSuspendListener() override { StartAndSuspendListenerInternal(); } |
| void StopListener() override { StopListenerInternal(); } |
| void SuspendListener() override { SuspendListenerInternal(); } |
| void ResumeListener() override { ResumeListenerInternal(); } |
| void SearchNow(ServiceListener::State from) override { |
| SearchNowInternal(from); |
| } |
| |
| // ServicePublisherImpl::Delegate overrides. |
| void StartPublisher() override { StartPublisherInternal(); } |
| void StartAndSuspendPublisher() override { |
| StartAndSuspendPublisherInternal(); |
| } |
| void StopPublisher() override { StopPublisherInternal(); } |
| void SuspendPublisher() override { SuspendPublisherInternal(); } |
| void ResumePublisher() override { ResumePublisherInternal(); } |
| |
| // Handles new events as OnRead does, but without the need of a TaskRunner. |
| void HandleNewEvents() { |
| if (!mdns_responder_) { |
| return; |
| } |
| |
| mdns_responder_->RunTasks(); |
| HandleMdnsEvents(); |
| } |
| }; |
| |
| class FakeMdnsResponderAdapterFactory final |
| : public MdnsResponderAdapterFactory, |
| public FakeMdnsResponderAdapter::LifetimeObserver { |
| public: |
| ~FakeMdnsResponderAdapterFactory() override = default; |
| |
| std::unique_ptr<MdnsResponderAdapter> Create() override { |
| auto mdns = std::make_unique<FakeMdnsResponderAdapter>(); |
| mdns->SetLifetimeObserver(this); |
| last_mdns_responder_ = mdns.get(); |
| ++instances_; |
| return mdns; |
| } |
| |
| void OnDestroyed() override { |
| last_running_ = last_mdns_responder_->running(); |
| last_registered_services_size_ = |
| last_mdns_responder_->registered_services().size(); |
| last_mdns_responder_ = nullptr; |
| } |
| |
| FakeMdnsResponderAdapter* last_mdns_responder() { |
| return last_mdns_responder_; |
| } |
| |
| int32_t instances() const { return instances_; } |
| bool last_running() const { return last_running_; } |
| size_t last_registered_services_size() const { |
| return last_registered_services_size_; |
| } |
| |
| private: |
| FakeMdnsResponderAdapter* last_mdns_responder_ = nullptr; |
| int32_t instances_ = 0; |
| bool last_running_ = false; |
| size_t last_registered_services_size_ = 0; |
| }; |
| |
| namespace { |
| |
| using ::testing::_; |
| |
| constexpr char kTestServiceInstance[] = "turtle"; |
| constexpr char kTestServiceName[] = "_foo"; |
| constexpr char kTestServiceProtocol[] = "_udp"; |
| constexpr char kTestHostname[] = "hostname"; |
| constexpr uint16_t kTestPort = 12345; |
| |
| // Wrapper around the above class. In MdnsResponderServiceTest, we need to both |
| // pass a unique_ptr to the created MdnsResponderService and to maintain a |
| // local pointer as well. Doing this with the same object causes a race |
| // condition, where ~FakeMdnsResponderAdapter() calls observer_->OnDestroyed() |
| // after the object is already deleted, resulting in a seg fault. This is to |
| // prevent that race condition. |
| class WrapperMdnsResponderAdapterFactory final |
| : public MdnsResponderAdapterFactory, |
| public FakeMdnsResponderAdapter::LifetimeObserver { |
| public: |
| explicit WrapperMdnsResponderAdapterFactory( |
| FakeMdnsResponderAdapterFactory* ptr) |
| : other_(ptr) {} |
| |
| std::unique_ptr<MdnsResponderAdapter> Create() override { |
| return other_->Create(); |
| } |
| |
| void OnDestroyed() override { other_->OnDestroyed(); } |
| |
| private: |
| FakeMdnsResponderAdapterFactory* other_; |
| }; |
| |
| class MockServiceListenerObserver final : public ServiceListener::Observer { |
| public: |
| ~MockServiceListenerObserver() override = default; |
| |
| MOCK_METHOD0(OnStarted, void()); |
| MOCK_METHOD0(OnStopped, void()); |
| MOCK_METHOD0(OnSuspended, void()); |
| MOCK_METHOD0(OnSearching, void()); |
| |
| MOCK_METHOD1(OnReceiverAdded, void(const ServiceInfo&)); |
| MOCK_METHOD1(OnReceiverChanged, void(const ServiceInfo&)); |
| MOCK_METHOD1(OnReceiverRemoved, void(const ServiceInfo&)); |
| MOCK_METHOD0(OnAllReceiversRemoved, void()); |
| |
| MOCK_METHOD1(OnError, void(ServiceListenerError)); |
| MOCK_METHOD1(OnMetrics, void(ServiceListener::Metrics)); |
| }; |
| |
| class MockServicePublisherObserver final : public ServicePublisher::Observer { |
| public: |
| ~MockServicePublisherObserver() override = default; |
| |
| MOCK_METHOD0(OnStarted, void()); |
| MOCK_METHOD0(OnStopped, void()); |
| MOCK_METHOD0(OnSuspended, void()); |
| MOCK_METHOD1(OnError, void(ServicePublisherError)); |
| MOCK_METHOD1(OnMetrics, void(ServicePublisher::Metrics)); |
| }; |
| |
| UdpSocket* const kDefaultSocket = |
| reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(16)); |
| UdpSocket* const kSecondSocket = |
| reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(24)); |
| |
| class MdnsResponderServiceTest : public ::testing::Test { |
| protected: |
| void SetUp() override { |
| mdns_responder_factory_ = |
| std::make_unique<FakeMdnsResponderAdapterFactory>(); |
| auto wrapper_factory = std::make_unique<WrapperMdnsResponderAdapterFactory>( |
| mdns_responder_factory_.get()); |
| clock_ = std::make_unique<FakeClock>(Clock::now()); |
| task_runner_ = std::make_unique<FakeTaskRunner>(clock_.get()); |
| auto platform_service = std::make_unique<FakeMdnsPlatformService>(); |
| fake_platform_service_ = platform_service.get(); |
| fake_platform_service_->set_interfaces(bound_interfaces_); |
| mdns_service_ = std::make_unique<TestingMdnsResponderService>( |
| task_runner_.get(), kTestServiceName, kTestServiceProtocol, |
| std::move(wrapper_factory), std::move(platform_service)); |
| service_listener_ = |
| std::make_unique<ServiceListenerImpl>(mdns_service_.get()); |
| service_listener_->AddObserver(&observer_); |
| |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {}, {{"model", "shifty"}}); |
| service_publisher_ = std::make_unique<ServicePublisherImpl>( |
| &publisher_observer_, mdns_service_.get()); |
| } |
| |
| std::unique_ptr<FakeClock> clock_; |
| std::unique_ptr<FakeTaskRunner> task_runner_; |
| MockServiceListenerObserver observer_; |
| FakeMdnsPlatformService* fake_platform_service_; |
| std::unique_ptr<FakeMdnsResponderAdapterFactory> mdns_responder_factory_; |
| std::unique_ptr<TestingMdnsResponderService> mdns_service_; |
| std::unique_ptr<ServiceListenerImpl> service_listener_; |
| MockServicePublisherObserver publisher_observer_; |
| std::unique_ptr<ServicePublisherImpl> service_publisher_; |
| const uint8_t default_mac_[6] = {0, 11, 22, 33, 44, 55}; |
| const uint8_t second_mac_[6] = {55, 33, 22, 33, 44, 77}; |
| const IPSubnet default_subnet_{IPAddress{192, 168, 3, 2}, 24}; |
| const IPSubnet second_subnet_{IPAddress{10, 0, 0, 3}, 24}; |
| std::vector<MdnsPlatformService::BoundInterface> bound_interfaces_{ |
| MdnsPlatformService::BoundInterface{ |
| InterfaceInfo{1, |
| default_mac_, |
| "eth0", |
| InterfaceInfo::Type::kEthernet, |
| {default_subnet_}}, |
| default_subnet_, kDefaultSocket}, |
| MdnsPlatformService::BoundInterface{ |
| InterfaceInfo{2, |
| second_mac_, |
| "eth1", |
| InterfaceInfo::Type::kEthernet, |
| {second_subnet_}}, |
| second_subnet_, kSecondSocket}, |
| }; |
| }; |
| |
| } // namespace |
| |
| TEST_F(MdnsResponderServiceTest, BasicServiceStates) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| std::string service_id; |
| EXPECT_CALL(observer_, OnReceiverAdded(_)) |
| .WillOnce(::testing::Invoke([&service_id](const ServiceInfo& info) { |
| service_id = info.service_id; |
| EXPECT_EQ(kTestServiceInstance, info.friendly_name); |
| EXPECT_EQ((IPEndpoint{{192, 168, 3, 7}, kTestPort}), info.v4_endpoint); |
| EXPECT_FALSE(info.v6_endpoint.address); |
| })); |
| mdns_service_->HandleNewEvents(); |
| |
| mdns_responder->AddAEvent(MakeAEvent( |
| "gigliorononomicon", IPAddress{192, 168, 3, 8}, kDefaultSocket)); |
| |
| EXPECT_CALL(observer_, OnReceiverChanged(_)) |
| .WillOnce(::testing::Invoke([&service_id](const ServiceInfo& info) { |
| EXPECT_EQ(service_id, info.service_id); |
| EXPECT_EQ(kTestServiceInstance, info.friendly_name); |
| EXPECT_EQ((IPEndpoint{{192, 168, 3, 8}, kTestPort}), info.v4_endpoint); |
| EXPECT_FALSE(info.v6_endpoint.address); |
| })); |
| mdns_service_->HandleNewEvents(); |
| |
| auto ptr_remove = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| ptr_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddPtrEvent(std::move(ptr_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)) |
| .WillOnce(::testing::Invoke([&service_id](const ServiceInfo& info) { |
| EXPECT_EQ(service_id, info.service_id); |
| })); |
| mdns_service_->HandleNewEvents(); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, NetworkNetworkInterfaceIndex) { |
| constexpr uint8_t mac[6] = {12, 34, 56, 78, 90}; |
| const IPSubnet subnet{IPAddress{10, 0, 0, 2}, 24}; |
| bound_interfaces_.emplace_back( |
| InterfaceInfo{2, mac, "wlan0", InterfaceInfo::Type::kWifi, {subnet}}, |
| subnet, kSecondSocket); |
| fake_platform_service_->set_interfaces(bound_interfaces_); |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kSecondSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)) |
| .WillOnce(::testing::Invoke([](const ServiceInfo& info) { |
| EXPECT_EQ(2, info.network_interface_index); |
| })); |
| mdns_service_->HandleNewEvents(); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, SimultaneousFieldChanges) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| mdns_responder->AddSrvEvent( |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", 54321, kDefaultSocket)); |
| auto a_remove = MakeAEvent("gigliorononomicon", IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| a_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddAEvent(std::move(a_remove)); |
| mdns_responder->AddAEvent(MakeAEvent( |
| "gigliorononomicon", IPAddress{192, 168, 3, 8}, kDefaultSocket)); |
| |
| EXPECT_CALL(observer_, OnReceiverChanged(_)) |
| .WillOnce(::testing::Invoke([](const ServiceInfo& info) { |
| EXPECT_EQ((IPAddress{192, 168, 3, 8}), info.v4_endpoint.address); |
| EXPECT_EQ(54321, info.v4_endpoint.port); |
| EXPECT_FALSE(info.v6_endpoint.address); |
| })); |
| mdns_service_->HandleNewEvents(); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, SimultaneousHostAndAddressChange) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| mdns_responder->AddSrvEvent( |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "alpha", kTestPort, kDefaultSocket)); |
| mdns_responder->AddAEvent(MakeAEvent( |
| "gigliorononomicon", IPAddress{192, 168, 3, 8}, kDefaultSocket)); |
| mdns_responder->AddAEvent( |
| MakeAEvent("alpha", IPAddress{192, 168, 3, 10}, kDefaultSocket)); |
| |
| EXPECT_CALL(observer_, OnReceiverChanged(_)) |
| .WillOnce(::testing::Invoke([](const ServiceInfo& info) { |
| EXPECT_EQ((IPAddress{192, 168, 3, 10}), info.v4_endpoint.address); |
| EXPECT_FALSE(info.v6_endpoint.address); |
| })); |
| mdns_service_->HandleNewEvents(); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, ListenerStateTransitions) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| EXPECT_CALL(observer_, OnSuspended()); |
| service_listener_->Suspend(); |
| ASSERT_EQ(mdns_responder, mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_FALSE(mdns_responder->running()); |
| |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Resume(); |
| ASSERT_EQ(mdns_responder, mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_TRUE(mdns_responder->running()); |
| |
| EXPECT_CALL(observer_, OnStopped()); |
| service_listener_->Stop(); |
| ASSERT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| |
| EXPECT_CALL(observer_, OnSuspended()); |
| auto instances = mdns_responder_factory_->instances(); |
| service_listener_->StartAndSuspend(); |
| EXPECT_EQ(instances + 1, mdns_responder_factory_->instances()); |
| mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| EXPECT_FALSE(mdns_responder->running()); |
| |
| EXPECT_CALL(observer_, OnStopped()); |
| service_listener_->Stop(); |
| ASSERT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, BasicServicePublish) { |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| const auto& services = mdns_responder->registered_services(); |
| ASSERT_EQ(1u, services.size()); |
| EXPECT_EQ(kTestServiceInstance, services[0].service_instance); |
| EXPECT_EQ(kTestServiceName, services[0].service_name); |
| EXPECT_EQ(kTestServiceProtocol, services[0].service_protocol); |
| auto host_labels = services[0].target_host.GetLabels(); |
| ASSERT_EQ(2u, host_labels.size()); |
| EXPECT_EQ(kTestHostname, host_labels[0]); |
| EXPECT_EQ("local", host_labels[1]); |
| EXPECT_EQ(kTestPort, services[0].target_port); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| |
| EXPECT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_EQ(0u, mdns_responder_factory_->last_registered_services_size()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, PublisherStateTransitions) { |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| EXPECT_EQ(1u, mdns_responder->registered_services().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnSuspended()); |
| service_publisher_->Suspend(); |
| EXPECT_EQ(0u, mdns_responder->registered_services().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Resume(); |
| EXPECT_EQ(1u, mdns_responder->registered_services().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| EXPECT_EQ(0u, mdns_responder_factory_->last_registered_services_size()); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| EXPECT_EQ(1u, mdns_responder->registered_services().size()); |
| EXPECT_CALL(publisher_observer_, OnSuspended()); |
| service_publisher_->Suspend(); |
| EXPECT_EQ(0u, mdns_responder->registered_services().size()); |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| EXPECT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_EQ(0u, mdns_responder_factory_->last_registered_services_size()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, PublisherObeysInterfaceAllowlist) { |
| { |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {}, {{"model", "shifty"}}); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(2u, interfaces.size()); |
| EXPECT_EQ(kDefaultSocket, interfaces[0].socket); |
| EXPECT_EQ(kSecondSocket, interfaces[1].socket); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| } |
| { |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {1, 2}, {{"model", "shifty"}}); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(2u, interfaces.size()); |
| EXPECT_EQ(kDefaultSocket, interfaces[0].socket); |
| EXPECT_EQ(kSecondSocket, interfaces[1].socket); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| } |
| { |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {2}, {{"model", "shifty"}}); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(1u, interfaces.size()); |
| EXPECT_EQ(kSecondSocket, interfaces[0].socket); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| } |
| } |
| |
| TEST_F(MdnsResponderServiceTest, ListenAndPublish) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| { |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(2u, interfaces.size()); |
| EXPECT_EQ(kDefaultSocket, interfaces[0].socket); |
| EXPECT_EQ(kSecondSocket, interfaces[1].socket); |
| } |
| |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {2}, {{"model", "shifty"}}); |
| |
| auto instances = mdns_responder_factory_->instances(); |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| EXPECT_EQ(instances, mdns_responder_factory_->instances()); |
| ASSERT_TRUE(mdns_responder->running()); |
| { |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(1u, interfaces.size()); |
| EXPECT_EQ(kSecondSocket, interfaces[0].socket); |
| } |
| |
| EXPECT_CALL(observer_, OnStopped()); |
| service_listener_->Stop(); |
| ASSERT_TRUE(mdns_responder->running()); |
| EXPECT_EQ(1u, mdns_responder->registered_interfaces().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| EXPECT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_EQ(0u, mdns_responder_factory_->last_registered_services_size()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, PublishAndListen) { |
| mdns_service_->SetServiceConfig(kTestHostname, kTestServiceInstance, |
| kTestPort, {2}, {{"model", "shifty"}}); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| { |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(1u, interfaces.size()); |
| EXPECT_EQ(kSecondSocket, interfaces[0].socket); |
| } |
| |
| auto instances = mdns_responder_factory_->instances(); |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| EXPECT_EQ(instances, mdns_responder_factory_->instances()); |
| ASSERT_TRUE(mdns_responder->running()); |
| { |
| auto interfaces = mdns_responder->registered_interfaces(); |
| ASSERT_EQ(1u, interfaces.size()); |
| EXPECT_EQ(kSecondSocket, interfaces[0].socket); |
| } |
| |
| EXPECT_CALL(publisher_observer_, OnStopped()); |
| service_publisher_->Stop(); |
| ASSERT_TRUE(mdns_responder->running()); |
| EXPECT_EQ(1u, mdns_responder->registered_interfaces().size()); |
| |
| EXPECT_CALL(observer_, OnStopped()); |
| service_listener_->Stop(); |
| EXPECT_FALSE(mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_EQ(0u, mdns_responder_factory_->last_registered_services_size()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, AddressQueryStopped) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_FALSE(mdns_responder->srv_queries_empty()); |
| EXPECT_FALSE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, AddressQueryRefCount) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| AddEventsForNewService(mdns_responder, "instance-2", kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", 4321, |
| {"model=shwofty", "id=asdf"}, |
| IPAddress{192, 168, 3, 7}, kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)).Times(2); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_FALSE(mdns_responder->srv_queries_empty()); |
| EXPECT_FALSE(mdns_responder->txt_queries_empty()); |
| EXPECT_FALSE(mdns_responder->a_queries_empty()); |
| EXPECT_FALSE(mdns_responder->aaaa_queries_empty()); |
| |
| srv_remove = |
| MakeSrvEvent("instance-2", kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", 4321, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_FALSE(mdns_responder->srv_queries_empty()); |
| EXPECT_FALSE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, ServiceQueriesStoppedSrvFirst) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_FALSE(mdns_responder->srv_queries_empty()); |
| EXPECT_FALSE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| |
| auto ptr_remove = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| ptr_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddPtrEvent(std::move(ptr_remove)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_TRUE(mdns_responder->srv_queries_empty()); |
| EXPECT_TRUE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, ServiceQueriesStoppedPtrFirst) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto ptr_remove = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| ptr_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddPtrEvent(std::move(ptr_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_FALSE(mdns_responder->srv_queries_empty()); |
| EXPECT_FALSE(mdns_responder->txt_queries_empty()); |
| EXPECT_FALSE(mdns_responder->a_queries_empty()); |
| EXPECT_FALSE(mdns_responder->aaaa_queries_empty()); |
| |
| auto srv_remove = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_TRUE(mdns_responder->srv_queries_empty()); |
| EXPECT_TRUE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, MultipleInterfaceRemove) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kSecondSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove1 = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kSecondSocket); |
| srv_remove1.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove1)); |
| EXPECT_CALL(observer_, OnReceiverChanged(_)).Times(0); |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)).Times(0); |
| mdns_service_->HandleNewEvents(); |
| |
| auto srv_remove2 = |
| MakeSrvEvent(kTestServiceInstance, kTestServiceName, kTestServiceProtocol, |
| "gigliorononomicon", kTestPort, kDefaultSocket); |
| srv_remove2.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddSrvEvent(std::move(srv_remove2)); |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| |
| auto ptr_remove = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| ptr_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddPtrEvent(std::move(ptr_remove)); |
| mdns_service_->HandleNewEvents(); |
| |
| EXPECT_FALSE(mdns_responder->ptr_queries_empty()); |
| EXPECT_TRUE(mdns_responder->srv_queries_empty()); |
| EXPECT_TRUE(mdns_responder->txt_queries_empty()); |
| EXPECT_TRUE(mdns_responder->a_queries_empty()); |
| EXPECT_TRUE(mdns_responder->aaaa_queries_empty()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, ResumeService) { |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| ASSERT_TRUE(mdns_responder); |
| ASSERT_TRUE(mdns_responder->running()); |
| |
| EXPECT_EQ(2u, mdns_responder->registered_interfaces().size()); |
| ASSERT_EQ(1u, mdns_responder->registered_services().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnSuspended()); |
| service_publisher_->Suspend(); |
| |
| EXPECT_TRUE(mdns_responder_factory_->last_mdns_responder()); |
| EXPECT_EQ(0u, mdns_responder->registered_services().size()); |
| |
| EXPECT_CALL(publisher_observer_, OnStarted()); |
| service_publisher_->Resume(); |
| |
| EXPECT_EQ(2u, mdns_responder->registered_interfaces().size()); |
| ASSERT_EQ(1u, mdns_responder->registered_services().size()); |
| } |
| |
| TEST_F(MdnsResponderServiceTest, RestorePtrNotifiesObserver) { |
| EXPECT_CALL(observer_, OnStarted()); |
| service_listener_->Start(); |
| |
| auto* mdns_responder = mdns_responder_factory_->last_mdns_responder(); |
| |
| AddEventsForNewService(mdns_responder, kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, "gigliorononomicon", kTestPort, |
| {"model=shifty", "id=asdf"}, IPAddress{192, 168, 3, 7}, |
| kDefaultSocket); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto ptr_remove = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| ptr_remove.header.response_type = QueryEventHeader::Type::kRemoved; |
| mdns_responder->AddPtrEvent(std::move(ptr_remove)); |
| |
| EXPECT_CALL(observer_, OnReceiverRemoved(_)); |
| mdns_service_->HandleNewEvents(); |
| |
| auto ptr_add = MakePtrEvent(kTestServiceInstance, kTestServiceName, |
| kTestServiceProtocol, kDefaultSocket); |
| mdns_responder->AddPtrEvent(std::move(ptr_add)); |
| |
| EXPECT_CALL(observer_, OnReceiverAdded(_)); |
| mdns_service_->HandleNewEvents(); |
| } |
| |
| } // namespace osp |
| } // namespace openscreen |
