src/chrome/browser/extensions/api/mdns/dns_sd_registry_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/mdns/dns_sd_registry.h"
   6 #include "chrome/browser/extensions/api/mdns/dns_sd_delegate.h"
   7 #include "chrome/browser/extensions/api/mdns/dns_sd_device_lister.h"
   8 #include "chrome/browser/local_discovery/service_discovery_host_client.h"
   9 #include "testing/gmock/include/gmock/gmock.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace extensions {
  13
  14 class MockDnsSdDeviceLister : public DnsSdDeviceLister {
  15  public:
  16   MockDnsSdDeviceLister() : DnsSdDeviceLister(NULL, NULL, "") {}
  17   virtual ~MockDnsSdDeviceLister() {}
  18
  19   virtual void Discover(bool force_update) OVERRIDE {}
  20 };
  21
  22 class TestDnsSdRegistry : public DnsSdRegistry {
  23  public:
  24   TestDnsSdRegistry() : DnsSdRegistry(NULL), delegate_(NULL) {}
  25   virtual ~TestDnsSdRegistry() {}
  26
  27   MockDnsSdDeviceLister* GetListerForService(const std::string& service_type) {
  28     return listers_[service_type];
  29   }
  30
  31   int GetServiceListenerCount(const std::string& service_type) {
  32     if (service_data_map_.find(service_type) == service_data_map_.end())
  33       return 0;
  34
  35     return service_data_map_[service_type].get()->GetListenerCount();
  36   }
  37
  38   DnsSdDelegate* GetDelegate() {
  39     return delegate_;
  40   }
  41
  42  protected:
  43   virtual DnsSdDeviceLister* CreateDnsSdDeviceLister(
  44       DnsSdDelegate* delegate,
  45       const std::string& service_type,
  46       local_discovery::ServiceDiscoverySharedClient* discovery_client)
  47           OVERRIDE {
  48     delegate_ = delegate;
  49     MockDnsSdDeviceLister* lister = new MockDnsSdDeviceLister();
  50     listers_[service_type] = lister;
  51     return lister;
  52   };
  53
  54  private:
  55   std::map<std::string, MockDnsSdDeviceLister*> listers_;
  56   // The last delegate used or NULL.
  57   DnsSdDelegate* delegate_;
  58 };
  59
  60 class MockDnsSdObserver : public DnsSdRegistry::DnsSdObserver {
  61  public:
  62   MOCK_METHOD2(OnDnsSdEvent, void(const std::string&,
  63                                   const DnsSdRegistry::DnsSdServiceList&));
  64 };
  65
  66 class DnsSdRegistryTest : public testing::Test {
  67  public:
  68   DnsSdRegistryTest() {}
  69   virtual ~DnsSdRegistryTest() {}
  70
  71   virtual void SetUp() OVERRIDE {
  72     registry_.reset(new TestDnsSdRegistry());
  73     registry_->AddObserver(&observer_);
  74   }
  75
  76  protected:
  77   scoped_ptr<TestDnsSdRegistry> registry_;
  78   MockDnsSdObserver observer_;
  79 };
  80
  81 // Tests registering 2 listeners and removing one. The device lister should
  82 // not be destroyed.
  83 TEST_F(DnsSdRegistryTest, RegisterUnregisterListeners) {
  84   const std::string service_type = "_testing._tcp.local";
  85
  86   EXPECT_CALL(observer_, OnDnsSdEvent(service_type,
  87       DnsSdRegistry::DnsSdServiceList())).Times(2);
  88
  89   registry_->RegisterDnsSdListener(service_type);
  90   registry_->RegisterDnsSdListener(service_type);
  91   registry_->UnregisterDnsSdListener(service_type);
  92   EXPECT_EQ(1, registry_->GetServiceListenerCount(service_type));
  93
  94   registry_->UnregisterDnsSdListener(service_type);
  95   EXPECT_EQ(0, registry_->GetServiceListenerCount(service_type));
  96 }
  97
  98 // Tests registering a listener and receiving an added and updated event.
  99 TEST_F(DnsSdRegistryTest, AddAndUpdate) {
 100   const std::string service_type = "_testing._tcp.local";
 101   const std::string ip_address1 = "192.168.0.100";
 102   const std::string ip_address2 = "192.168.0.101";
 103
 104   DnsSdService service;
 105   service.service_name = "_myDevice." + service_type;
 106   service.ip_address = ip_address1;
 107
 108   DnsSdRegistry::DnsSdServiceList service_list;
 109
 110   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 111
 112   // Add first service.
 113   service_list.push_back(service);
 114   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 115
 116   // Clear services and add same one with different IP address.
 117   service_list.clear();
 118   service.ip_address = ip_address2;
 119   service_list.push_back(service);
 120   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 121
 122   registry_->RegisterDnsSdListener(service_type);
 123   service.ip_address = ip_address1;
 124   registry_->GetDelegate()->ServiceChanged(service_type, true, service);
 125   service.ip_address = ip_address2;
 126   registry_->GetDelegate()->ServiceChanged(service_type, false, service);
 127 }
 128
 129 // Tests registering a listener and receiving an added and removed event.
 130 TEST_F(DnsSdRegistryTest, AddAndRemove) {
 131   const std::string service_type = "_testing._tcp.local";
 132
 133   DnsSdService service;
 134   service.service_name = "_myDevice." + service_type;
 135   service.ip_address = "192.168.0.100";
 136
 137   DnsSdRegistry::DnsSdServiceList service_list;
 138   // Expect to be called twice with empty list (once on register, once after
 139   // removing).
 140   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)).Times(2);
 141   service_list.push_back(service);
 142   // Expect to be called twice with 1 item (once after adding, once after adding
 143   // again after removal).
 144   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list)).Times(2);
 145
 146   registry_->RegisterDnsSdListener(service_type);
 147   registry_->GetDelegate()->ServiceChanged(service_type, true, service);
 148   registry_->GetDelegate()->ServiceRemoved(service_type, service.service_name);
 149   registry_->GetDelegate()->ServiceChanged(service_type, true, service);
 150 }
 151
 152 // Tests adding multiple services.
 153 TEST_F(DnsSdRegistryTest, AddMultipleServices) {
 154   const std::string service_type = "_testing._tcp.local";
 155
 156   DnsSdService service;
 157   service.service_name = "_myDevice." + service_type;
 158   service.ip_address = "192.168.0.100";
 159
 160   DnsSdService service2;
 161   service.service_name = "_myDevice2." + service_type;
 162   service.ip_address = "192.168.0.101";
 163
 164   DnsSdRegistry::DnsSdServiceList service_list;
 165   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 166   service_list.push_back(service);
 167   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 168   service_list.push_back(service2);
 169   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 170
 171   registry_->RegisterDnsSdListener(service_type);
 172   registry_->GetDelegate()->ServiceChanged(service_type, true, service);
 173   registry_->GetDelegate()->ServiceChanged(service_type, true, service2);
 174 }
 175
 176 // Tests adding multiple services and handling a flush event.
 177 TEST_F(DnsSdRegistryTest, FlushCache) {
 178   testing::InSequence s;
 179   const std::string service_type = "_testing._tcp.local";
 180
 181   DnsSdService service;
 182   service.service_name = "_myDevice." + service_type;
 183   service.ip_address = "192.168.0.100";
 184
 185   DnsSdService service2;
 186   service.service_name = "_myDevice2." + service_type;
 187   service.ip_address = "192.168.0.101";
 188
 189   DnsSdRegistry::DnsSdServiceList service_list;
 190   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 191   service_list.push_back(service);
 192   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 193   service_list.push_back(service2);
 194   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 195   service_list.clear();
 196   EXPECT_CALL(observer_, OnDnsSdEvent(service_type, service_list));
 197
 198   registry_->RegisterDnsSdListener(service_type);
 199   registry_->GetDelegate()->ServiceChanged(service_type, true, service);
 200   registry_->GetDelegate()->ServiceChanged(service_type, true, service2);
 201   registry_->GetDelegate()->ServicesFlushed(service_type);
 202 }
 203
 204
 205 }  // namespace extensions