// Copyright 2020 The Fuchsia 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 "src/connectivity/network/mdns/service/agents/instance_responder.h"

#include <lib/zx/time.h>

#include <gtest/gtest.h>

#include "src/connectivity/network/mdns/service/common/mdns_names.h"
#include "src/connectivity/network/mdns/service/common/service_instance.h"
#include "src/connectivity/network/mdns/service/test/agent_test.h"

namespace mdns {
namespace test {

const inet::IpPort kPort = inet::IpPort::From_uint16_t(2525);
const inet::IpPort kZeroPort = inet::IpPort::From_uint16_t(0);
constexpr char kServiceName[] = "_test._tcp.";
constexpr char kOtherServiceName[] = "_other._tcp.";
constexpr char kInstanceName[] = "testinstance";
constexpr char kHostName[] = "test2host";
constexpr char kHostFullName[] = "test2host.local.";
constexpr char kLocalHostNameLong[] = "testhostnamethatislong";
constexpr char kLocalHostFullNameLong[] = "testhostnamethatislong.local.";
constexpr char kAltHostName[] = "123456789ABC";
constexpr char kAltHostFullName[] = "123456789ABC.local.";
const std::vector<inet::IpAddress> kAddresses{inet::IpAddress(192, 168, 1, 200),
                                              inet::IpAddress(192, 168, 1, 201)};
const std::vector<inet::SocketAddress> kSocketAddresses{
    inet::SocketAddress(192, 168, 1, 200, kPort), inet::SocketAddress(192, 168, 1, 201, kPort)};
const std::vector<inet::SocketAddress> kSocketAddressesZeroPort{
    inet::SocketAddress(192, 168, 1, 200, kZeroPort),
    inet::SocketAddress(192, 168, 1, 201, kZeroPort)};
const std::vector<HostAddress> kHostAddresses{
    HostAddress(inet::IpAddress(192, 168, 1, 200), 1, zx::sec(450)),
    HostAddress(inet::IpAddress(192, 168, 1, 201), 1, zx::sec(450))};
const std::vector<HostAddress> kAlternateHostAddresses{
    HostAddress(inet::IpAddress(192, 168, 1, 202), 1, zx::sec(450)),
    HostAddress(inet::IpAddress(192, 168, 1, 203), 1, zx::sec(450))};
static constexpr size_t kMaxSenderAddresses = 64;
constexpr uint32_t kInterfaceId = 1;

class InstanceResponderTest : public AgentTest, public Mdns::Publisher {
 public:
  InstanceResponderTest() {}

 protected:
  static std::string service_full_name() { return MdnsNames::ServiceFullName(kServiceName); }

  static std::string instance_full_name() {
    return MdnsNames::InstanceFullName(kInstanceName, kServiceName);
  }

  // Expects that the agent has not called |ReportSuccess|.
  void ExpectNoReportSuccessCall() { EXPECT_FALSE(report_success_parameter_.has_value()); }

  // Expects that the agent has not called |GetPublication|.
  void ExpectNoGetPublicationCall() { EXPECT_TRUE(get_publication_calls_.empty()); }

  // Expects that the agent has called |GetPublication| with the given parameters. Returns the
  // callback passed to |GetPublication|.
  fit::function<void(std::unique_ptr<Mdns::Publication>)> ExpectGetPublicationCall(
      PublicationCause publication_cause, const std::string& subtype,
      const std::vector<inet::SocketAddress>& source_addresses);

  // Expects that nothing else has happened.
  void ExpectNoOther() override;

  // Expects a sequence of announcements made after startup.
  void ExpectAnnouncements(Media media = Media::kBoth, IpVersions ip_versions = IpVersions::kBoth,
                           const std::string& host_full_name = kLocalHostFullName,
                           const std::vector<inet::IpAddress>& addresses = {},
                           inet::IpPort port = kPort);

  // Expects a single announcement (a 'GetPublication' call and subsequent publication).
  void ExpectAnnouncement(Media media = Media::kBoth, IpVersions ip_versions = IpVersions::kBoth,
                          const std::string& host_full_name = kLocalHostFullName,
                          const std::vector<inet::IpAddress>& addresses = {},
                          inet::IpPort port = kPort);

  // Expects a single multicast publication.
  void ExpectPublication(Media media = Media::kBoth, IpVersions ip_versions = IpVersions::kBoth,
                         const std::string& host_full_name = kLocalHostFullName,
                         const std::vector<inet::IpAddress>& addresses = {},
                         inet::IpPort port = kPort);

  // Expects a single publication to the given reply address and subtype.
  void ExpectPublication(ReplyAddress reply_address, const std::string& subtype = "",
                         const std::string& host_full_name = kLocalHostFullName,
                         const std::vector<inet::IpAddress>& addresses = {},
                         inet::IpPort port = kPort,
                         MdnsResourceSection ptr_section = MdnsResourceSection::kAnswer,
                         MdnsResourceSection srv_section = MdnsResourceSection::kAdditional,
                         MdnsResourceSection txt_section = MdnsResourceSection::kAdditional);

  ReplyAddress MulticastReply(Media media, IpVersions ip_versions);

 private:
  struct GetPublicationCall {
    PublicationCause publication_cause_;
    const std::string subtype_;
    std::vector<inet::SocketAddress> source_addresses_;
    fit::function<void(std::unique_ptr<Mdns::Publication>)> callback_;
  };

  // |Mdns::Publisher| implementation.
  void ReportSuccess(bool success) override { report_success_parameter_.emplace(success); }

  void GetPublication(PublicationCause publication_cause, const std::string& subtype,
                      const std::vector<inet::SocketAddress>& source_addresses,
                      fit::function<void(std::unique_ptr<Mdns::Publication>)> callback) override {
    get_publication_calls_.push(GetPublicationCall{.publication_cause_ = publication_cause,
                                                   .subtype_ = subtype,
                                                   .source_addresses_ = source_addresses,
                                                   .callback_ = std::move(callback)});
  }

  std::optional<bool> report_success_parameter_;
  std::queue<GetPublicationCall> get_publication_calls_;
};

fit::function<void(std::unique_ptr<Mdns::Publication>)>
InstanceResponderTest::ExpectGetPublicationCall(
    PublicationCause publication_cause, const std::string& subtype,
    const std::vector<inet::SocketAddress>& source_addresses) {
  EXPECT_FALSE(get_publication_calls_.empty());
  EXPECT_EQ(publication_cause, get_publication_calls_.front().publication_cause_);
  EXPECT_EQ(subtype, get_publication_calls_.front().subtype_);
  auto callback = std::move(get_publication_calls_.front().callback_);
  EXPECT_EQ(source_addresses, get_publication_calls_.front().source_addresses_);
  EXPECT_NE(nullptr, callback);
  get_publication_calls_.pop();
  return callback;
}

void InstanceResponderTest::ExpectNoOther() {
  AgentTest::ExpectNoOther();
  ExpectNoReportSuccessCall();
  ExpectNoGetPublicationCall();
}

void InstanceResponderTest::ExpectAnnouncements(Media media, IpVersions ip_versions,
                                                const std::string& host_full_name,
                                                const std::vector<inet::IpAddress>& addresses,
                                                inet::IpPort port) {
  ExpectAnnouncement(media, ip_versions, host_full_name, addresses, port);
  ExpectPostTaskForTimeAndInvoke(zx::sec(1), zx::sec(1));
  ExpectAnnouncement(media, ip_versions, host_full_name, addresses, port);
  ExpectPostTaskForTimeAndInvoke(zx::sec(2), zx::sec(2));
  ExpectAnnouncement(media, ip_versions, host_full_name, addresses, port);
  ExpectPostTaskForTimeAndInvoke(zx::sec(4), zx::sec(4));
  ExpectAnnouncement(media, ip_versions, host_full_name, addresses, port);
  ExpectNoOther();
}

void InstanceResponderTest::ExpectAnnouncement(Media media, IpVersions ip_versions,
                                               const std::string& host_full_name,
                                               const std::vector<inet::IpAddress>& addresses,
                                               inet::IpPort port) {
  ExpectGetPublicationCall(PublicationCause::kAnnouncement, "",
                           {})(Mdns::Publication::Create(port));
  ExpectPublication(media, ip_versions, host_full_name, addresses, port);
}

ReplyAddress InstanceResponderTest::MulticastReply(Media media, IpVersions ip_versions) {
  return ReplyAddress::Multicast(media, ip_versions);
}

void InstanceResponderTest::ExpectPublication(Media media, IpVersions ip_versions,
                                              const std::string& host_full_name,
                                              const std::vector<inet::IpAddress>& addresses,
                                              inet::IpPort port) {
  ExpectPublication(MulticastReply(media, ip_versions), "", host_full_name, addresses, port);
}

void InstanceResponderTest::ExpectPublication(ReplyAddress reply_address,
                                              const std::string& subtype,
                                              const std::string& host_full_name,
                                              const std::vector<inet::IpAddress>& addresses,
                                              inet::IpPort port, MdnsResourceSection ptr_section,
                                              MdnsResourceSection srv_section,
                                              MdnsResourceSection txt_section) {
  auto message = ExpectOutboundMessage(reply_address);

  auto resource = ExpectResource(message.get(), ptr_section, service_full_name(), DnsType::kPtr,
                                 DnsClass::kIn, false);
  EXPECT_EQ(instance_full_name(), resource->ptr_.pointer_domain_name_.dotted_string_);

  if (subtype != "") {
    resource = ExpectResource(message.get(), ptr_section, subtype + "._sub." + service_full_name(),
                              DnsType::kPtr, DnsClass::kIn, false);
    EXPECT_EQ(instance_full_name(), resource->ptr_.pointer_domain_name_.dotted_string_);
  }

  resource = ExpectResource(message.get(), srv_section, instance_full_name(), DnsType::kSrv);
  EXPECT_EQ(0, resource->srv_.priority_);
  EXPECT_EQ(0, resource->srv_.weight_);
  EXPECT_EQ(port, resource->srv_.port_);
  EXPECT_EQ(host_full_name, resource->srv_.target_.dotted_string_);

  resource = ExpectResource(message.get(), txt_section, instance_full_name(), DnsType::kTxt);
  EXPECT_TRUE(resource->txt_.strings_.empty());

  if (addresses.empty()) {
    ExpectResource(message.get(), MdnsResourceSection::kAdditional, host_full_name, DnsType::kA);
  } else {
    ExpectAddresses(message.get(), MdnsResourceSection::kAdditional, host_full_name, addresses);
  }

  ExpectNoOtherQuestionOrResource(message.get());
}

// Tests initial startup of the responder.
TEST_F(InstanceResponderTest, Startup) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();
}

// Tests that multicast sends are rate-limited.
TEST_F(InstanceResponderTest, MulticastRateLimit) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address0(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);
  ReplyAddress sender_address1(
      inet::SocketAddress(192, 168, 1, 2, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  // First question.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address0);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address0.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  // Second question - answer should be delayed 1s.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address0);
  ExpectPostTaskForTimeAndInvoke(zx::sec(1), zx::sec(1));
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address0.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTimeAndInvoke(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  // Third question - no delay, because 60 virtual seconds have passed.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address0);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address0.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  // Fourth and fifth questions - one answer, delayed 1s.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address0);
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address1);
  ExpectPostTaskForTimeAndInvoke(zx::sec(1), zx::sec(1));
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address0.socket_address(), sender_address1.socket_address()})(
      Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTimeAndInvoke(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that source addresses are limited to pertinent queries.
TEST_F(InstanceResponderTest, SourceAddresses) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address0(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);
  ReplyAddress sender_address1(
      inet::SocketAddress(192, 168, 1, 2, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  // Irrelevant question.
  under_test.ReceiveQuestion(
      DnsQuestion(MdnsNames::ServiceFullName(kOtherServiceName), DnsType::kPtr),
      ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth), sender_address0);

  // Pertient question.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address1);

  // Expect only pertinent sender address.
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address1.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that at most 64 source addresses are sent.
TEST_F(InstanceResponderTest, SourceAddressLimit) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  // First question.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);

  // Expect one sender address.
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  // Second question asked 65 times.
  for (size_t i = 0; i <= kMaxSenderAddresses; ++i) {
    under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                               ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                               sender_address);
  }
  ExpectPostTaskForTimeAndInvoke(zx::sec(1), zx::sec(1));

  // Expect 64 sender addresses.
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address(),
                            sender_address.socket_address(), sender_address.socket_address()})(
      Mdns::Publication::Create(kPort));
  ExpectPublication();
  ExpectPostTaskForTimeAndInvoke(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a wireless-only responder announces over wireless only and only responds to
// questions received via wireless interfaces.
TEST_F(InstanceResponderTest, WirelessOnly) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kWireless,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kWireless);

  ReplyAddress wired_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  ReplyAddress wireless_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWireless, IpVersions::kBoth);

  // Question from wired should be ignored.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             wired_sender_address);
  ExpectNoGetPublicationCall();
  ExpectNoOther();

  // Question from wireless should be answered.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             wireless_sender_address);
  ExpectGetPublicationCall(
      PublicationCause::kQueryMulticastResponse, "",
      {wireless_sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kWireless);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a wired-only responder announces over wired only and only responds to questions
// received via wired interfaces.
TEST_F(InstanceResponderTest, WiredOnly) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kWired,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kWired);

  ReplyAddress wireless_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWireless, IpVersions::kBoth);

  // Question from wireless should be ignored.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             wireless_sender_address);
  ExpectNoGetPublicationCall();
  ExpectNoOther();

  ReplyAddress wired_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  // Question from wired should be answered.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             wired_sender_address);
  ExpectGetPublicationCall(
      PublicationCause::kQueryMulticastResponse, "",
      {wired_sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kWired);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a IPv4-only responder announces over IPv4 only and only responds to
// questions received via IPv4 interfaces.
TEST_F(InstanceResponderTest, V4Only) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kV4, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kBoth, IpVersions::kV4);

  ReplyAddress v6_sender_address(inet::SocketAddress(0xfe80, 1, inet::IpPort::From_uint16_t(5353)),
                                 inet::IpAddress(0xfe80, 100), kInterfaceId, Media::kWired,
                                 IpVersions::kV6);

  ReplyAddress v4_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWireless, IpVersions::kV4);

  // Question from IPv6 should be ignored.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             v6_sender_address);
  ExpectNoGetPublicationCall();
  ExpectNoOther();

  // Question from IPv4 should be answered.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             v4_sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {v4_sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kBoth, IpVersions::kV4);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a IPv6-only responder announces over IPv6 only and only responds to
// questions received via IPv6 interfaces.
TEST_F(InstanceResponderTest, V6Only) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kV6, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kBoth, IpVersions::kV6);

  ReplyAddress v4_sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWireless, IpVersions::kV4);

  ReplyAddress v6_sender_address(inet::SocketAddress(0xfe80, 1, inet::IpPort::From_uint16_t(5353)),
                                 inet::IpAddress(0xfe80, 100), kInterfaceId, Media::kWired,
                                 IpVersions::kV6);

  // Question from IPv4 should be ignored.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             v4_sender_address);
  ExpectNoGetPublicationCall();
  ExpectNoOther();

  // Question from IPv6 should be answered.
  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             v6_sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {v6_sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kBoth, IpVersions::kV6);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a query for a unicast response is recognized as such.
TEST_F(InstanceResponderTest, Unicast) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  auto question = DnsQuestion(service_full_name(), DnsType::kPtr);
  question.unicast_response_ = true;
  under_test.ReceiveQuestion(question, sender_address, sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryUnicastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(sender_address);
  ExpectNoOther();
}

// Tests that subtypes are properly communicated.
TEST_F(InstanceResponderTest, Subtype) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  under_test.ReceiveQuestion(DnsQuestion("_cookies._sub." + service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "_cookies",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(MulticastReply(Media::kBoth, IpVersions::kBoth), "_cookies");
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a responder for an alternate host announces and responds correctly.
TEST_F(InstanceResponderTest, HostAndAddresses) {
  InstanceResponder under_test(this, kHostName, kAddresses, kServiceName, kInstanceName,
                               Media::kBoth, IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kBoth, IpVersions::kBoth, kHostFullName, kAddresses);

  ReplyAddress sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kBoth, IpVersions::kBoth, kHostFullName, kAddresses);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that local service instance notifications are properly generated.
TEST_F(InstanceResponderTest, LocalServiceInstanceNotifications) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);
  SetLocalHostAddresses(kHostAddresses);

  // Normal startup. We use a long host name, because there was a bug that only happened when the
  // host full name was greater than sizeof(std::string), which is 24 bytes.
  under_test.Start(kLocalHostFullNameLong);
  ExpectAnnouncements(Media::kBoth, IpVersions::kBoth, kLocalHostFullNameLong);

  ReplyAddress sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kBoth, IpVersions::kBoth, kLocalHostFullNameLong);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  ExpectAddLocalServiceInstanceCall(
      ServiceInstance(kServiceName, kInstanceName, kLocalHostNameLong, kSocketAddresses), false);
}

// Tests that local service instance notifications are properly generated for proxy instances.
TEST_F(InstanceResponderTest, LocalServiceInstanceNotificationsProxy) {
  InstanceResponder under_test(this, kHostName, kAddresses, kServiceName, kInstanceName,
                               Media::kBoth, IpVersions::kBoth, this);
  SetAgent(under_test);
  // Use alternate host addresses to test for regression of https://fxbug.dev/42057148 fix.
  SetLocalHostAddresses(kAlternateHostAddresses);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kBoth, IpVersions::kBoth, kHostFullName, kAddresses);

  ReplyAddress sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(Media::kBoth, IpVersions::kBoth, kHostFullName, kAddresses);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  ExpectAddLocalServiceInstanceCall(
      ServiceInstance(kServiceName, kInstanceName, kHostName, kSocketAddresses), true);
}

// Tests that local service instance notifications are properly generated when the port is zero.
TEST_F(InstanceResponderTest, LocalServiceInstanceNotificationsZeroPort) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);
  SetLocalHostAddresses(kHostAddresses);

  // Normal startup. We use a long host name, because there was a bug that only happened when the
  // host full name was greater than sizeof(std::string), which is 24 bytes.
  under_test.Start(kLocalHostFullNameLong);
  ExpectAnnouncements(Media::kBoth, IpVersions::kBoth, kLocalHostFullNameLong, {}, kZeroPort);

  ReplyAddress sender_address(
      inet::SocketAddress(192, 168, 1, 1, inet::IpPort::From_uint16_t(5353)),
      inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired, IpVersions::kBoth);

  under_test.ReceiveQuestion(DnsQuestion(service_full_name(), DnsType::kPtr),
                             ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kZeroPort));
  ExpectPublication(Media::kBoth, IpVersions::kBoth, kLocalHostFullNameLong, {}, kZeroPort);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();

  ExpectAddLocalServiceInstanceCall(
      ServiceInstance(kServiceName, kInstanceName, kLocalHostNameLong, kSocketAddressesZeroPort),
      false);
}

// Tests the the responder works with an alternate host name.
TEST_F(InstanceResponderTest, AltHostName) {
  InstanceResponder under_test(this, kAltHostName, {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements(Media::kBoth, IpVersions::kBoth, kAltHostFullName);
}

// Tests that a query for SRV elicits the correct response.
TEST_F(InstanceResponderTest, SrvQuestion) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  auto question = DnsQuestion(instance_full_name(), DnsType::kSrv);
  under_test.ReceiveQuestion(question, ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(MulticastReply(Media::kBoth, IpVersions::kBoth), "", kLocalHostFullName, {},
                    kPort, MdnsResourceSection::kAdditional, MdnsResourceSection::kAnswer,
                    MdnsResourceSection::kAdditional);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a query for TXT elicits the correct response.
TEST_F(InstanceResponderTest, TxtQuestion) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  auto question = DnsQuestion(instance_full_name(), DnsType::kTxt);
  under_test.ReceiveQuestion(question, ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(MulticastReply(Media::kBoth, IpVersions::kBoth), "", kLocalHostFullName, {},
                    kPort, MdnsResourceSection::kAdditional, MdnsResourceSection::kAdditional,
                    MdnsResourceSection::kAnswer);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a query for ANY for the instance elicits the correct response.
TEST_F(InstanceResponderTest, AnyForInstanceQuestion) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  auto question = DnsQuestion(instance_full_name(), DnsType::kAny);
  under_test.ReceiveQuestion(question, ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(MulticastReply(Media::kBoth, IpVersions::kBoth), "", kLocalHostFullName, {},
                    kPort, MdnsResourceSection::kAdditional, MdnsResourceSection::kAnswer,
                    MdnsResourceSection::kAnswer);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

// Tests that a query for ANY for the service type elicits the correct response.
TEST_F(InstanceResponderTest, AnyForServiceTypeQuestion) {
  InstanceResponder under_test(this, "", {}, kServiceName, kInstanceName, Media::kBoth,
                               IpVersions::kBoth, this);
  SetAgent(under_test);

  // Normal startup.
  under_test.Start(kLocalHostFullName);
  ExpectAnnouncements();

  ReplyAddress sender_address(inet::SocketAddress(192, 168, 1, 1, kPort),
                              inet::IpAddress(192, 168, 1, 100), kInterfaceId, Media::kWired,
                              IpVersions::kBoth);

  auto question = DnsQuestion(service_full_name(), DnsType::kAny);
  under_test.ReceiveQuestion(question, ReplyAddress::Multicast(Media::kBoth, IpVersions::kBoth),
                             sender_address);
  ExpectGetPublicationCall(PublicationCause::kQueryMulticastResponse, "",
                           {sender_address.socket_address()})(Mdns::Publication::Create(kPort));
  ExpectPublication(MulticastReply(Media::kBoth, IpVersions::kBoth), "", kLocalHostFullName, {},
                    kPort, MdnsResourceSection::kAnswer, MdnsResourceSection::kAdditional,
                    MdnsResourceSection::kAdditional);
  ExpectPostTaskForTime(zx::sec(60), zx::sec(60));  // idle cleanup
  ExpectNoOther();
}

}  // namespace test
}  // namespace mdns