| // Copyright 2019 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 "discovery/dnssd/impl/querier_impl.h" |
| |
| #include <memory> |
| #include <string> |
| #include <utility> |
| |
| #include "absl/strings/str_join.h" |
| #include "absl/strings/str_split.h" |
| #include "absl/types/optional.h" |
| #include "discovery/common/testing/mock_reporting_client.h" |
| #include "discovery/dnssd/impl/conversion_layer.h" |
| #include "discovery/dnssd/testing/fake_network_interface_config.h" |
| #include "discovery/mdns/mdns_records.h" |
| #include "discovery/mdns/testing/mdns_test_util.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include "platform/test/fake_clock.h" |
| #include "platform/test/fake_task_runner.h" |
| #include "util/osp_logging.h" |
| |
| namespace openscreen { |
| namespace discovery { |
| namespace { |
| |
| NetworkInterfaceIndex kNetworkInterface = 0; |
| |
| class MockCallback : public DnsSdQuerier::Callback { |
| public: |
| MOCK_METHOD1(OnEndpointCreated, void(const DnsSdInstanceEndpoint&)); |
| MOCK_METHOD1(OnEndpointUpdated, void(const DnsSdInstanceEndpoint&)); |
| MOCK_METHOD1(OnEndpointDeleted, void(const DnsSdInstanceEndpoint&)); |
| }; |
| |
| class MockMdnsService : public MdnsService { |
| public: |
| MOCK_METHOD4( |
| StartQuery, |
| void(const DomainName&, DnsType, DnsClass, MdnsRecordChangedCallback*)); |
| |
| MOCK_METHOD4( |
| StopQuery, |
| void(const DomainName&, DnsType, DnsClass, MdnsRecordChangedCallback*)); |
| |
| MOCK_METHOD1(ReinitializeQueries, void(const DomainName& name)); |
| |
| // Unused. |
| MOCK_METHOD3(StartProbe, |
| Error(MdnsDomainConfirmedProvider*, DomainName, IPAddress)); |
| MOCK_METHOD1(RegisterRecord, Error(const MdnsRecord&)); |
| MOCK_METHOD1(UnregisterRecord, Error(const MdnsRecord&)); |
| MOCK_METHOD2(UpdateRegisteredRecord, |
| Error(const MdnsRecord&, const MdnsRecord&)); |
| }; |
| |
| class MockDnsDataGraph : public DnsDataGraph { |
| public: |
| MOCK_METHOD2(StartTracking, |
| void(const DomainName& domain, |
| DomainChangeCallback on_start_tracking)); |
| MOCK_METHOD2(StopTracking, |
| void(const DomainName& domain, |
| DomainChangeCallback on_start_tracking)); |
| |
| MOCK_CONST_METHOD2( |
| CreateEndpoints, |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>>(DomainGroup, |
| const DomainName&)); |
| |
| MOCK_METHOD4(ApplyDataRecordChange, |
| Error(MdnsRecord, |
| RecordChangedEvent, |
| DomainChangeCallback, |
| DomainChangeCallback)); |
| |
| MOCK_CONST_METHOD0(GetTrackedDomainCount, size_t()); |
| |
| MOCK_CONST_METHOD1(IsTracked, bool(const DomainName&)); |
| }; |
| |
| } // namespace |
| |
| using testing::_; |
| using testing::ByMove; |
| using testing::Return; |
| using testing::StrictMock; |
| |
| class QuerierImplTesting : public QuerierImpl { |
| public: |
| QuerierImplTesting() |
| : QuerierImpl(&mock_service_, |
| &task_runner_, |
| &reporting_client_, |
| &network_config_), |
| clock_(Clock::now()), |
| task_runner_(&clock_) {} |
| |
| StrictMock<MockMdnsService>& service() { return mock_service_; } |
| |
| StrictMock<MockReportingClient>& reporting_client() { |
| return reporting_client_; |
| } |
| |
| // NOTE: This should only be used for testing hard-to-achieve edge cases. |
| StrictMock<MockDnsDataGraph>& GetMockedGraph() { |
| if (!is_graph_mocked_) { |
| graph_ = std::make_unique<StrictMock<MockDnsDataGraph>>(); |
| is_graph_mocked_ = true; |
| } |
| |
| return static_cast<StrictMock<MockDnsDataGraph>&>(*graph_); |
| } |
| |
| size_t GetTrackedDomainCount() { return graph_->GetTrackedDomainCount(); } |
| |
| bool IsDomainTracked(const DomainName& domain) { |
| return graph_->IsTracked(domain); |
| } |
| |
| using QuerierImpl::OnRecordChanged; |
| |
| private: |
| FakeClock clock_; |
| FakeTaskRunner task_runner_; |
| FakeNetworkInterfaceConfig network_config_; |
| StrictMock<MockMdnsService> mock_service_; |
| StrictMock<MockReportingClient> reporting_client_; |
| |
| bool is_graph_mocked_ = false; |
| }; |
| |
| class DnsSdQuerierImplTest : public testing::Test { |
| public: |
| DnsSdQuerierImplTest() |
| : querier(std::make_unique<QuerierImplTesting>()), |
| ptr_domain(DomainName{"_service", "_udp", domain}), |
| name(DomainName{instance, "_service", "_udp", domain}), |
| name2(DomainName{instance2, "_service", "_udp", domain}) { |
| EXPECT_FALSE(querier->IsQueryRunning(service)); |
| |
| EXPECT_CALL(querier->service(), |
| StartQuery(_, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->StartQuery(service, &callback); |
| EXPECT_TRUE(querier->IsQueryRunning(service)); |
| testing::Mock::VerifyAndClearExpectations(&querier->service()); |
| |
| EXPECT_TRUE(querier->IsQueryRunning(service)); |
| testing::Mock::VerifyAndClearExpectations(&querier->service()); |
| } |
| |
| protected: |
| void ValidateRecordChangeStartsQuery( |
| const std::vector<PendingQueryChange>& changes, |
| const DomainName& name, |
| size_t expected_size) { |
| ValidateRecordChangeResult(changes, name, expected_size, |
| PendingQueryChange::kStartQuery); |
| } |
| |
| void ValidateRecordChangeStopsQuery( |
| const std::vector<PendingQueryChange>& changes, |
| const DomainName& name, |
| size_t expected_size) { |
| ValidateRecordChangeResult(changes, name, expected_size, |
| PendingQueryChange::kStopQuery); |
| } |
| |
| void CreateServiceInstance(const DomainName& service_domain, |
| MockCallback* cb) { |
| MdnsRecord ptr = GetFakePtrRecord(service_domain); |
| MdnsRecord srv = GetFakeSrvRecord(service_domain); |
| MdnsRecord txt = GetFakeTxtRecord(service_domain); |
| MdnsRecord a = GetFakeARecord(service_domain); |
| MdnsRecord aaaa = GetFakeAAAARecord(service_domain); |
| |
| auto result = querier->OnRecordChanged(ptr, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(result, service_domain, 1); |
| |
| // NOTE: This verbose iterator handling is used to avoid gcc failures. |
| auto it = service_domain.labels().begin(); |
| it++; |
| std::string service_name = *it; |
| it++; |
| std::string service_protocol = *it; |
| std::string service_id = ""; |
| service_id.append(std::move(service_name)) |
| .append(".") |
| .append(std::move(service_protocol)); |
| ASSERT_TRUE(querier->IsQueryRunning(service_id)); |
| |
| result = querier->OnRecordChanged(srv, RecordChangedEvent::kCreated); |
| EXPECT_EQ(result.size(), size_t{0}); |
| |
| result = querier->OnRecordChanged(a, RecordChangedEvent::kCreated); |
| EXPECT_EQ(result.size(), size_t{0}); |
| |
| result = querier->OnRecordChanged(aaaa, RecordChangedEvent::kCreated); |
| EXPECT_EQ(result.size(), size_t{0}); |
| |
| EXPECT_CALL(*cb, OnEndpointCreated(_)).Times(1); |
| result = querier->OnRecordChanged(txt, RecordChangedEvent::kCreated); |
| EXPECT_EQ(result.size(), size_t{0}); |
| testing::Mock::VerifyAndClearExpectations(cb); |
| } |
| |
| std::string instance = "instance"; |
| std::string instance2 = "instance2"; |
| std::string service = "_service._udp"; |
| std::string service2 = "_service2._udp"; |
| std::string domain = "local"; |
| StrictMock<MockCallback> callback; |
| std::unique_ptr<QuerierImplTesting> querier; |
| DomainName ptr_domain; |
| DomainName name; |
| DomainName name2; |
| |
| private: |
| void ValidateRecordChangeResult( |
| const std::vector<PendingQueryChange>& changes, |
| const DomainName& name, |
| size_t expected_size, |
| PendingQueryChange::ChangeType change_type) { |
| EXPECT_EQ(changes.size(), expected_size); |
| auto it = std::find_if( |
| changes.begin(), changes.end(), |
| [&name, change_type](const PendingQueryChange& change) { |
| return change.dns_type == DnsType::kANY && |
| change.dns_class == DnsClass::kANY && |
| change.change_type == change_type && change.name == name; |
| }); |
| EXPECT_TRUE(it != changes.end()); |
| } |
| }; |
| |
| // Common Use Cases |
| // |
| // The below tests validate the common use cases for QuerierImpl, which we |
| // expect will be hit for reasonable actors on the network. For these tests, the |
| // real DnsDataGraph object will be used. |
| |
| TEST_F(DnsSdQuerierImplTest, TestStartStopQueryCallsMdnsQueries) { |
| DomainName other_service_id( |
| DomainName{instance2, "_service2", "_udp", domain}); |
| |
| StrictMock<MockCallback> callback2; |
| EXPECT_FALSE(querier->IsQueryRunning(service2)); |
| |
| EXPECT_CALL(querier->service(), |
| StartQuery(_, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->StartQuery(service2, &callback2); |
| EXPECT_TRUE(querier->IsQueryRunning(service2)); |
| |
| EXPECT_CALL(querier->service(), |
| StopQuery(_, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->StopQuery(service2, &callback2); |
| EXPECT_FALSE(querier->IsQueryRunning(service2)); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestStartDuplicateQueryFiresCallbacksWhenAble) { |
| StrictMock<MockCallback> callback2; |
| CreateServiceInstance(name, &callback); |
| |
| EXPECT_CALL(callback2, OnEndpointCreated(_)).Times(1); |
| querier->StartQuery(service, &callback2); |
| testing::Mock::VerifyAndClearExpectations(&callback2); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestStopQueryStopsTrackingRecords) { |
| CreateServiceInstance(name, &callback); |
| |
| DomainName ptr_domain(++name.labels().begin(), name.labels().end()); |
| EXPECT_CALL(querier->service(), |
| StopQuery(ptr_domain, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| EXPECT_CALL(querier->service(), |
| StopQuery(name, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->StopQuery(service, &callback); |
| EXPECT_FALSE(querier->IsDomainTracked(ptr_domain)); |
| EXPECT_FALSE(querier->IsDomainTracked(name)); |
| EXPECT_EQ(querier->GetTrackedDomainCount(), size_t{0}); |
| testing::Mock::VerifyAndClearExpectations(&callback); |
| |
| EXPECT_CALL(querier->service(), |
| StartQuery(_, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->StartQuery(service, &callback); |
| EXPECT_TRUE(querier->IsQueryRunning(service)); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestStopNonexistantQueryHasNoEffect) { |
| StrictMock<MockCallback> callback2; |
| querier->StopQuery(service, &callback2); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestAFollowingAAAAFiresSecondCallback) { |
| MdnsRecord ptr = GetFakePtrRecord(name); |
| MdnsRecord srv = GetFakeSrvRecord(name); |
| MdnsRecord txt = GetFakeTxtRecord(name); |
| MdnsRecord a = GetFakeARecord(name); |
| MdnsRecord aaaa = GetFakeAAAARecord(name); |
| |
| std::vector<DnsSdInstanceEndpoint> endpoints; |
| auto changes = querier->OnRecordChanged(ptr, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, name, 1); |
| |
| changes = querier->OnRecordChanged(srv, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| changes = querier->OnRecordChanged(txt, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| EXPECT_CALL(callback, OnEndpointCreated(_)) |
| .WillOnce([&endpoints](const DnsSdInstanceEndpoint& ep) mutable { |
| endpoints.push_back(ep); |
| }); |
| changes = querier->OnRecordChanged(aaaa, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| testing::Mock::VerifyAndClearExpectations(&callback); |
| |
| EXPECT_CALL(callback, OnEndpointUpdated(_)) |
| .WillOnce([&endpoints](const DnsSdInstanceEndpoint& ep) mutable { |
| endpoints.push_back(ep); |
| }); |
| changes = querier->OnRecordChanged(a, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| testing::Mock::VerifyAndClearExpectations(&callback); |
| |
| ASSERT_EQ(endpoints.size(), size_t{2}); |
| DnsSdInstanceEndpoint& created = endpoints[0]; |
| DnsSdInstanceEndpoint& updated = endpoints[1]; |
| EXPECT_EQ(static_cast<DnsSdInstance>(created), |
| static_cast<DnsSdInstance>(updated)); |
| |
| ASSERT_EQ(created.addresses().size(), size_t{1}); |
| EXPECT_TRUE(created.addresses()[0].IsV6()); |
| |
| ASSERT_EQ(updated.addresses().size(), size_t{2}); |
| EXPECT_TRUE(created.addresses()[0] == updated.addresses()[0] || |
| created.addresses()[0] == updated.addresses()[1]); |
| EXPECT_TRUE(updated.addresses()[0].IsV4() || updated.addresses()[1].IsV4()); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestGenerateTwoRecordsCallsCallbackTwice) { |
| DomainName third{"android", "local"}; |
| MdnsRecord ptr1 = GetFakePtrRecord(name); |
| MdnsRecord srv1 = GetFakeSrvRecord(name, third); |
| MdnsRecord txt1 = GetFakeTxtRecord(name); |
| MdnsRecord ptr2 = GetFakePtrRecord(name2); |
| MdnsRecord srv2 = GetFakeSrvRecord(name2, third); |
| MdnsRecord txt2 = GetFakeTxtRecord(name2); |
| MdnsRecord a = GetFakeARecord(third); |
| |
| auto changes = querier->OnRecordChanged(ptr1, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, name, 1); |
| |
| changes = querier->OnRecordChanged(srv1, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, third, 1); |
| |
| changes = querier->OnRecordChanged(txt1, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| changes = querier->OnRecordChanged(ptr2, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, name2, 1); |
| |
| changes = querier->OnRecordChanged(srv2, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| changes = querier->OnRecordChanged(txt2, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| EXPECT_CALL(callback, OnEndpointCreated(_)).Times(2); |
| changes = querier->OnRecordChanged(a, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| testing::Mock::VerifyAndClearExpectations(&callback); |
| |
| EXPECT_CALL(callback, OnEndpointDeleted(_)).Times(2); |
| changes = querier->OnRecordChanged(a, RecordChangedEvent::kExpired); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, TestCreateDeletePtrRecordResults) { |
| const auto ptr = GetFakePtrRecord(name); |
| |
| auto result = querier->OnRecordChanged(ptr, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(result, name, 1); |
| |
| result = querier->OnRecordChanged(ptr, RecordChangedEvent::kExpired); |
| ValidateRecordChangeStopsQuery(result, name, 1); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, CallbackCalledWhenPtrDeleted) { |
| MdnsRecord ptr = GetFakePtrRecord(name); |
| MdnsRecord srv = GetFakeSrvRecord(name, name2); |
| MdnsRecord txt = GetFakeTxtRecord(name); |
| MdnsRecord a = GetFakeARecord(name2); |
| |
| auto changes = querier->OnRecordChanged(ptr, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, name, 1); |
| |
| changes = querier->OnRecordChanged(srv, RecordChangedEvent::kCreated); |
| ValidateRecordChangeStartsQuery(changes, name2, 1); |
| |
| changes = querier->OnRecordChanged(txt, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| EXPECT_CALL(callback, OnEndpointCreated(_)); |
| changes = querier->OnRecordChanged(a, RecordChangedEvent::kCreated); |
| EXPECT_EQ(changes.size(), size_t{0}); |
| |
| EXPECT_CALL(callback, OnEndpointDeleted(_)); |
| changes = querier->OnRecordChanged(ptr, RecordChangedEvent::kExpired); |
| ValidateRecordChangeStopsQuery(changes, name, 2); |
| ValidateRecordChangeStopsQuery(changes, name2, 2); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, HardRefresh) { |
| MdnsRecord ptr = GetFakePtrRecord(name); |
| MdnsRecord srv = GetFakeSrvRecord(name, name2); |
| MdnsRecord txt = GetFakeTxtRecord(name); |
| MdnsRecord a = GetFakeARecord(name2); |
| |
| querier->OnRecordChanged(ptr, RecordChangedEvent::kCreated); |
| querier->OnRecordChanged(srv, RecordChangedEvent::kCreated); |
| querier->OnRecordChanged(txt, RecordChangedEvent::kCreated); |
| |
| EXPECT_CALL(callback, OnEndpointCreated(_)); |
| querier->OnRecordChanged(a, RecordChangedEvent::kCreated); |
| testing::Mock::VerifyAndClearExpectations(&callback); |
| |
| EXPECT_CALL(querier->service(), |
| StopQuery(ptr_domain, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| EXPECT_CALL(querier->service(), |
| StopQuery(name, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| EXPECT_CALL(querier->service(), |
| StopQuery(name2, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| EXPECT_CALL(querier->service(), ReinitializeQueries(_)).Times(1); |
| EXPECT_CALL(querier->service(), |
| StartQuery(ptr_domain, DnsType::kANY, DnsClass::kANY, _)) |
| .Times(1); |
| querier->ReinitializeQueries(service); |
| testing::Mock::VerifyAndClearExpectations(querier.get()); |
| } |
| |
| // Edge Cases |
| // |
| // The below tests validate against edge cases that either either difficult to |
| // achieve, are not expected to be possible under normal circumstances but |
| // should be validated against for safety, or should only occur when either a |
| // bad actor or a misbehaving publisher is present on the network. To simplify |
| // these tests, the DnsDataGraph object will be mocked. |
| TEST_F(DnsSdQuerierImplTest, ErrorsOnlyAfterChangesAreLogged) { |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| after_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| |
| // Calls before and after applying record changes, then the error it logs. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| EXPECT_CALL(querier->reporting_client(), OnRecoverableError(_)).Times(3); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, ErrorsOnlyBeforeChangesNotLogged) { |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| |
| // Calls before and after applying record changes. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, ErrorsBeforeAndAfterChangesNotLogged) { |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| after_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| |
| // Calls before and after applying record changes. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, OrderOfErrorsDoesNotAffectResults) { |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| before_changes.emplace_back(Error::Code::kIndexOutOfBounds); |
| before_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| before_changes.emplace_back(Error::Code::kOperationCancelled); |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kOperationInProgress); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| after_changes.emplace_back(Error::Code::kOperationInProgress); |
| after_changes.emplace_back(Error::Code::kUnknownError); |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| after_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| after_changes.emplace_back(Error::Code::kOperationCancelled); |
| |
| // Calls before and after applying record changes, then the error it logs. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| EXPECT_CALL(querier->reporting_client(), OnRecoverableError(_)).Times(1); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, ResultsWithMultipleAddressRecordsHandled) { |
| IPEndpoint endpointa{{192, 168, 86, 23}, 80}; |
| IPEndpoint endpointb{{1, 2, 3, 4, 5, 6, 7, 8}, 80}; |
| IPEndpoint endpointc{{192, 168, 0, 1}, 80}; |
| IPEndpoint endpointd{{192, 168, 0, 2}, 80}; |
| IPEndpoint endpointe{{192, 168, 0, 3}, 80}; |
| |
| DnsSdInstanceEndpoint instance1("instance1", "_service._udp", "local", {}, |
| kNetworkInterface, {endpointa, endpointb}); |
| DnsSdInstanceEndpoint instance2("instance2", "_service2._udp", "local", {}, |
| kNetworkInterface, {endpointa, endpointb}); |
| DnsSdInstanceEndpoint instance3("instance3", "_service._udp", "local", {}, |
| kNetworkInterface, {endpointc}); |
| DnsSdInstanceEndpoint instance4("instance1", "_service3._udp", "local", {}, |
| kNetworkInterface, {endpointd, endpointe}); |
| DnsSdInstanceEndpoint instance5("instance1", "_service3._udp", "local", {}, |
| kNetworkInterface, {endpointe}); |
| |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| before_changes.emplace_back(instance4); |
| before_changes.emplace_back(instance2); |
| before_changes.emplace_back(instance3); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| after_changes.emplace_back(instance5); |
| after_changes.emplace_back(instance3); |
| after_changes.emplace_back(instance1); |
| |
| // Calls before and after applying record changes, then the error it logs. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| EXPECT_CALL(callback, OnEndpointCreated(instance1)); |
| EXPECT_CALL(callback, OnEndpointUpdated(instance5)); |
| EXPECT_CALL(callback, OnEndpointDeleted(instance2)); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| TEST_F(DnsSdQuerierImplTest, MixOfErrorsAndSuccessesHandledCorrectly) { |
| DnsSdInstanceEndpoint instance1("instance1", "_service._udp", "local", {}, |
| kNetworkInterface, {{{192, 168, 2, 24}, 80}}); |
| DnsSdInstanceEndpoint instance2("instance2", "_service2._udp", "local", {}, |
| kNetworkInterface, {{{192, 168, 17, 2}, 80}}); |
| DnsSdInstanceEndpoint instance3("instance3", "_service._udp", "local", {}, |
| kNetworkInterface, {{{127, 0, 0, 1}, 80}}); |
| DnsSdInstanceEndpoint instance4("instance1", "_service3._udp", "local", {}, |
| kNetworkInterface, {{{127, 0, 0, 1}, 80}}); |
| DnsSdInstanceEndpoint instance5("instance1", "_service3._udp", "local", {}, |
| kNetworkInterface, |
| {{{127, 0, 0, 1}, 80}, {{127, 0, 0, 2}, 80}}); |
| |
| MockDnsDataGraph& mock_graph = querier->GetMockedGraph(); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> before_changes{}; |
| before_changes.emplace_back(Error::Code::kIndexOutOfBounds); |
| before_changes.emplace_back(instance2); |
| before_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| before_changes.emplace_back(Error::Code::kOperationCancelled); |
| before_changes.emplace_back(instance1); |
| before_changes.emplace_back(Error::Code::kItemNotFound); |
| before_changes.emplace_back(Error::Code::kOperationInProgress); |
| before_changes.emplace_back(instance4); |
| std::vector<ErrorOr<DnsSdInstanceEndpoint>> after_changes{}; |
| after_changes.emplace_back(instance1); |
| after_changes.emplace_back(Error::Code::kOperationInProgress); |
| after_changes.emplace_back(Error::Code::kUnknownError); |
| after_changes.emplace_back(Error::Code::kItemNotFound); |
| after_changes.emplace_back(Error::Code::kItemAlreadyExists); |
| after_changes.emplace_back(instance3); |
| after_changes.emplace_back(instance5); |
| after_changes.emplace_back(Error::Code::kOperationCancelled); |
| |
| // Calls before and after applying record changes, then the error it logs. |
| EXPECT_CALL(mock_graph, CreateEndpoints(_, _)) |
| .WillOnce(Return(ByMove(std::move(before_changes)))) |
| .WillOnce(Return(ByMove(std::move(after_changes)))); |
| EXPECT_CALL(querier->reporting_client(), OnRecoverableError(_)).Times(1); |
| EXPECT_CALL(callback, OnEndpointCreated(instance3)); |
| EXPECT_CALL(callback, OnEndpointUpdated(instance5)); |
| EXPECT_CALL(callback, OnEndpointDeleted(instance2)); |
| |
| // Call to apply record changes. The specifics are unimportant. |
| EXPECT_CALL(mock_graph, ApplyDataRecordChange(_, _, _, _)) |
| .WillOnce(Return(Error::None())); |
| |
| // Call with any record. The mocks make the specifics unimportant. |
| querier->OnRecordChanged(GetFakePtrRecord(name), |
| RecordChangedEvent::kCreated); |
| } |
| |
| } // namespace discovery |
| } // namespace openscreen |
