peerd/discovered_peer_unittest.cc - chromiumos/platform2 - Git at Google

 // Copyright 2014 The Chromium OS 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 "peerd/discovered_peer.h"

 #include <string>

 #include <base/time/time.h>
 #include <dbus/bus.h>
 #include <dbus/mock_bus.h>
 #include <dbus/mock_exported_object.h>
 #include <dbus/object_path.h>
 #include <chromeos/dbus/async_event_sequencer.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "peerd/technologies.h"
 #include "peerd/test_util.h"

 using base::Time;
 using chromeos::dbus_utils::AsyncEventSequencer;
 using dbus::ObjectPath;
 using dbus::MockExportedObject;
 using peerd::technologies::tech_t;
 using std::string;
 using std::unique_ptr;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Mock;
 using testing::Property;
 using testing::Return;
 using testing::_;

 namespace {

 const char kPeerPath[] = "/org/chromium/peerd/peers/1";
 const char kServicePath[] = "/org/chromium/peerd/peers/1/services/1";

 const char kPeerId[] = "123e4567-e89b-12d3-a456-426655440000";
 // Initial peer values.
 const char kName[] = "friendly name";
 const char kNote[] = "descriptive note";
 const time_t kPeerLastSeen = 100;
 // Updated version of those fields.
 const char kNewName[] = "new friendly name";
 const char kNewNote[] = "new descriptive note";
 const time_t kNewPeerLastSeen = 200;
 // Bad values for peer fields.
 const char kBadName[] = "#evil name";
 const char kBadNote[] = "#evil note";
 const time_t kStalePeerLastSeen = 5;
 // Service bits.
 const char kServiceId[] = "a-service-id";
 const char kBadServiceId[] = "#bad_service_id";
 const time_t kServiceStaleLastSeen = 201;
 const time_t kServiceLastSeen = 225;
 const time_t kServiceNewLastSeen = 250;

 tech_t kFakeTech1 = 1 << 29;
 tech_t kFakeTech2 = 1 << 30;

 }  // namespace

 namespace peerd {

 class DiscoveredPeerTest : public testing::Test {
  public:
   void SetUp() override {
     // Ignore threading concerns.
     EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     // We're going to set up a DiscoveredPeer; it needs a DBusObject.
     EXPECT_CALL(*bus_, GetExportedObject(Property(&ObjectPath::value,
                                                   kPeerPath)))
         .WillOnce(Return(peer_object_.get()));
     EXPECT_CALL(*peer_object_, ExportMethod(_, _, _, _))
         .WillRepeatedly(Invoke(&test_util::HandleMethodExport));
     peer_.reset(new DiscoveredPeer{bus_, nullptr, ObjectPath{kPeerPath},
                                    kFakeTech1});
     EXPECT_TRUE(peer_->RegisterAsync(
         nullptr, kPeerId, kName, kNote, Time::FromTimeT(kPeerLastSeen),
         AsyncEventSequencer::GetDefaultCompletionAction()));
     // By default, no services should be exported.
     EXPECT_CALL(*bus_, GetExportedObject(_)) .Times(0);
     EXPECT_CALL(*service_object_, Unregister()).Times(0);
     // Don't worry about signals.
     EXPECT_CALL(*peer_object_, SendSignal(_)).Times(AnyNumber());
     EXPECT_CALL(*service_object_, SendSignal(_)).Times(AnyNumber());
   }

   void TearDown() override {
     Mock::VerifyAndClearExpectations(peer_object_.get());
     Mock::VerifyAndClearExpectations(service_object_.get());
     EXPECT_CALL(*peer_object_, Unregister()).Times(1);
     if (service_exposed_) {
       ExpectServiceRemoved();
     }
   }

   void ExpectInitialPeerValues() {
     EXPECT_EQ(kName, peer_->GetFriendlyName());
     EXPECT_EQ(kNote, peer_->GetNote());
     EXPECT_EQ(Time::FromTimeT(kPeerLastSeen), peer_->GetLastSeen());
   }

   void ExpectServiceExposed() {
     service_exposed_ = true;
     EXPECT_CALL(*bus_, GetExportedObject(Property(&ObjectPath::value,
                                                   kServicePath)))
         .WillOnce(Return(service_object_.get()));
     EXPECT_CALL(*service_object_, ExportMethod(_, _, _, _))
         .WillRepeatedly(Invoke(&test_util::HandleMethodExport));
   }

   void ExpectServiceRemoved() {
     Mock::VerifyAndClearExpectations(service_object_.get());
     service_exposed_ = false;
     EXPECT_CALL(*service_object_, Unregister()).Times(1);
   }


   void ExpectNoServicesDiscovered() {
     EXPECT_TRUE(peer_->service_metadata_.empty());
     EXPECT_TRUE(peer_->services_.empty());
   }

   void ExpectServiceHasValues(const string& service_id,
                               const Service::IpAddresses& ip_addr,
                               const Service::ServiceInfo& info,
                               const base::Time& last_seen,
                               tech_t tech) {
     auto service_it = peer_->services_.find(service_id);
     auto metadata_it = peer_->service_metadata_.find(service_id);
     // Better find this peer in both collections of data.
     ASSERT_NE(service_it, peer_->services_.end());
     ASSERT_NE(metadata_it, peer_->service_metadata_.end());
     // Fields in the peer should match.
     EXPECT_EQ(ip_addr, service_it->second->GetIpAddresses());
     EXPECT_EQ(info, service_it->second->GetServiceInfo());
     // Metadata should also match.
     EXPECT_EQ(last_seen, metadata_it->second.last_seen);
     EXPECT_EQ(tech, metadata_it->second.technology);
   }

   scoped_refptr<dbus::MockBus> bus_{new dbus::MockBus{dbus::Bus::Options{}}};
   scoped_refptr<MockExportedObject> peer_object_{
       new MockExportedObject{bus_.get(), ObjectPath{kPeerPath}}};
   scoped_refptr<MockExportedObject> service_object_{
       new MockExportedObject{bus_.get(), ObjectPath{kServicePath}}};
   bool service_exposed_{false};
   unique_ptr<DiscoveredPeer> peer_;
 };

 TEST_F(DiscoveredPeerTest, CanUpdateFromAdvertisement) {
   peer_->UpdateFromAdvertisement(kNewName, kNewNote,
                                  Time::FromTimeT(kNewPeerLastSeen),
                                  kFakeTech1);
   EXPECT_EQ(kNewName, peer_->GetFriendlyName());
   EXPECT_EQ(kNewNote, peer_->GetNote());
   EXPECT_EQ(Time::FromTimeT(kNewPeerLastSeen), peer_->GetLastSeen());
   EXPECT_EQ(1, peer_->GetTechnologyCount());
 }

 TEST_F(DiscoveredPeerTest, CannotUpdateFromInvalidAdvertisement) {
   peer_->UpdateFromAdvertisement(kBadName, kNewNote,
                                  Time::FromTimeT(kNewPeerLastSeen),
                                  kFakeTech1);
   ExpectInitialPeerValues();
 }

 TEST_F(DiscoveredPeerTest, CannotPartiallyUpdatePeer) {
   // Only invalid note.
   peer_->UpdateFromAdvertisement(kNewName, kBadNote,
                                  Time::FromTimeT(kNewPeerLastSeen),
                                  kFakeTech1);
   ExpectInitialPeerValues();
   // Only invalid name.
   peer_->UpdateFromAdvertisement(kBadName, kNewNote,
                                  Time::FromTimeT(kNewPeerLastSeen),
                                  kFakeTech1);
   ExpectInitialPeerValues();
   // Stale advertisement.
   peer_->UpdateFromAdvertisement(kNewName, kNewNote,
                                  Time::FromTimeT(kStalePeerLastSeen),
                                  kFakeTech1);
   ExpectInitialPeerValues();
 }

 TEST_F(DiscoveredPeerTest, CanAddService) {
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                        kFakeTech1);
 }

 TEST_F(DiscoveredPeerTest, CannotPartiallyAddService) {
   peer_->UpdateService(kBadServiceId, {}, {},
                        Time::FromTimeT(kServiceLastSeen), kFakeTech1);
   ExpectNoServicesDiscovered();
 }

 TEST_F(DiscoveredPeerTest, CannotAddServiceForUnknownTechnology) {
   peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                        kFakeTech2);
 }

 TEST_F(DiscoveredPeerTest, CanUpdateService) {
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {},
                        Time::FromTimeT(kServiceLastSeen), kFakeTech1);
   const Service::ServiceInfo valid_info{{"good_key", "valid value"}};
   peer_->UpdateService(kServiceId, {}, valid_info,
                        Time::FromTimeT(kServiceNewLastSeen), kFakeTech1);
   ExpectServiceHasValues(kServiceId, {}, valid_info,
                          Time::FromTimeT(kServiceNewLastSeen),
                          kFakeTech1);
 }

 TEST_F(DiscoveredPeerTest, CannotPartiallyUpdateService) {
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {},
                        Time::FromTimeT(kServiceLastSeen), kFakeTech1);
   const Service::ServiceInfo invalid_info{{"#badkey", "valid value"}};
   peer_->UpdateService(kServiceId, {}, invalid_info,
                        Time::FromTimeT(kServiceLastSeen), kFakeTech2);
   ExpectServiceHasValues(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                          kFakeTech1);
 }

 TEST_F(DiscoveredPeerTest, ShouldRejectStaleServiceUpdate) {
   peer_->UpdateFromAdvertisement(kName, kNote,
                                  Time::FromTimeT(kPeerLastSeen),
                                  kFakeTech2);
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {},
                        Time::FromTimeT(kServiceLastSeen), kFakeTech1);
   const Service::ServiceInfo valid_info{{"good_key", "valid value"}};
   peer_->UpdateService(kServiceId, {}, valid_info,
                        Time::FromTimeT(kServiceStaleLastSeen), kFakeTech2);
   ExpectServiceHasValues(kServiceId, {}, {},
                          Time::FromTimeT(kServiceLastSeen), kFakeTech1);
 }

 TEST_F(DiscoveredPeerTest, RemoveTechnologyIsRecursive) {
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                        kFakeTech1);
   ExpectServiceRemoved();
   peer_->RemoveTechnology(kFakeTech1);
 }

 TEST_F(DiscoveredPeerTest, HandlesMultipleTechnologies) {
   peer_->UpdateFromAdvertisement(kNewName, kNewNote,
                                  Time::FromTimeT(kNewPeerLastSeen),
                                  kFakeTech2);
   EXPECT_EQ(2, peer_->GetTechnologyCount());
   ExpectServiceExposed();
   peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                        kFakeTech1);
   // This should not create a new service object, just touch the existing one.
   peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
                        kFakeTech2);
   peer_->RemoveTechnology(kFakeTech2);
   EXPECT_EQ(1, peer_->GetTechnologyCount());
   ExpectServiceRemoved();
   peer_->RemoveTechnologyFromService(kServiceId, kFakeTech1);
 }

 }  // namespace peerd
	// Copyright 2014 The Chromium OS 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 "peerd/discovered_peer.h"

	#include <string>

	#include <base/time/time.h>
	#include <dbus/bus.h>
	#include <dbus/mock_bus.h>
	#include <dbus/mock_exported_object.h>
	#include <dbus/object_path.h>
	#include <chromeos/dbus/async_event_sequencer.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "peerd/technologies.h"
	#include "peerd/test_util.h"

	using base::Time;
	using chromeos::dbus_utils::AsyncEventSequencer;
	using dbus::ObjectPath;
	using dbus::MockExportedObject;
	using peerd::technologies::tech_t;
	using std::string;
	using std::unique_ptr;
	using testing::AnyNumber;
	using testing::Invoke;
	using testing::Mock;
	using testing::Property;
	using testing::Return;
	using testing::_;

	namespace {

	const char kPeerPath[] = "/org/chromium/peerd/peers/1";
	const char kServicePath[] = "/org/chromium/peerd/peers/1/services/1";

	const char kPeerId[] = "123e4567-e89b-12d3-a456-426655440000";
	// Initial peer values.
	const char kName[] = "friendly name";
	const char kNote[] = "descriptive note";
	const time_t kPeerLastSeen = 100;
	// Updated version of those fields.
	const char kNewName[] = "new friendly name";
	const char kNewNote[] = "new descriptive note";
	const time_t kNewPeerLastSeen = 200;
	// Bad values for peer fields.
	const char kBadName[] = "#evil name";
	const char kBadNote[] = "#evil note";
	const time_t kStalePeerLastSeen = 5;
	// Service bits.
	const char kServiceId[] = "a-service-id";
	const char kBadServiceId[] = "#bad_service_id";
	const time_t kServiceStaleLastSeen = 201;
	const time_t kServiceLastSeen = 225;
	const time_t kServiceNewLastSeen = 250;

	tech_t kFakeTech1 = 1 << 29;
	tech_t kFakeTech2 = 1 << 30;

	} // namespace

	namespace peerd {

	class DiscoveredPeerTest : public testing::Test {
	public:
	void SetUp() override {
	// Ignore threading concerns.
	EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
	EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
	// We're going to set up a DiscoveredPeer; it needs a DBusObject.
	EXPECT_CALL(*bus_, GetExportedObject(Property(&ObjectPath::value,
	kPeerPath)))
	.WillOnce(Return(peer_object_.get()));
	EXPECT_CALL(*peer_object_, ExportMethod(_, _, _, _))
	.WillRepeatedly(Invoke(&test_util::HandleMethodExport));
	peer_.reset(new DiscoveredPeer{bus_, nullptr, ObjectPath{kPeerPath},
	kFakeTech1});
	EXPECT_TRUE(peer_->RegisterAsync(
	nullptr, kPeerId, kName, kNote, Time::FromTimeT(kPeerLastSeen),
	AsyncEventSequencer::GetDefaultCompletionAction()));
	// By default, no services should be exported.
	EXPECT_CALL(*bus_, GetExportedObject(_)) .Times(0);
	EXPECT_CALL(*service_object_, Unregister()).Times(0);
	// Don't worry about signals.
	EXPECT_CALL(*peer_object_, SendSignal(_)).Times(AnyNumber());
	EXPECT_CALL(*service_object_, SendSignal(_)).Times(AnyNumber());
	}

	void TearDown() override {
	Mock::VerifyAndClearExpectations(peer_object_.get());
	Mock::VerifyAndClearExpectations(service_object_.get());
	EXPECT_CALL(*peer_object_, Unregister()).Times(1);
	if (service_exposed_) {
	ExpectServiceRemoved();
	}
	}

	void ExpectInitialPeerValues() {
	EXPECT_EQ(kName, peer_->GetFriendlyName());
	EXPECT_EQ(kNote, peer_->GetNote());
	EXPECT_EQ(Time::FromTimeT(kPeerLastSeen), peer_->GetLastSeen());
	}

	void ExpectServiceExposed() {
	service_exposed_ = true;
	EXPECT_CALL(*bus_, GetExportedObject(Property(&ObjectPath::value,
	kServicePath)))
	.WillOnce(Return(service_object_.get()));
	EXPECT_CALL(*service_object_, ExportMethod(_, _, _, _))
	.WillRepeatedly(Invoke(&test_util::HandleMethodExport));
	}

	void ExpectServiceRemoved() {
	Mock::VerifyAndClearExpectations(service_object_.get());
	service_exposed_ = false;
	EXPECT_CALL(*service_object_, Unregister()).Times(1);
	}


	void ExpectNoServicesDiscovered() {
	EXPECT_TRUE(peer_->service_metadata_.empty());
	EXPECT_TRUE(peer_->services_.empty());
	}

	void ExpectServiceHasValues(const string& service_id,
	const Service::IpAddresses& ip_addr,
	const Service::ServiceInfo& info,
	const base::Time& last_seen,
	tech_t tech) {
	auto service_it = peer_->services_.find(service_id);
	auto metadata_it = peer_->service_metadata_.find(service_id);
	// Better find this peer in both collections of data.
	ASSERT_NE(service_it, peer_->services_.end());
	ASSERT_NE(metadata_it, peer_->service_metadata_.end());
	// Fields in the peer should match.
	EXPECT_EQ(ip_addr, service_it->second->GetIpAddresses());
	EXPECT_EQ(info, service_it->second->GetServiceInfo());
	// Metadata should also match.
	EXPECT_EQ(last_seen, metadata_it->second.last_seen);
	EXPECT_EQ(tech, metadata_it->second.technology);
	}

	scoped_refptr<dbus::MockBus> bus_{new dbus::MockBus{dbus::Bus::Options{}}};
	scoped_refptr<MockExportedObject> peer_object_{
	new MockExportedObject{bus_.get(), ObjectPath{kPeerPath}}};
	scoped_refptr<MockExportedObject> service_object_{
	new MockExportedObject{bus_.get(), ObjectPath{kServicePath}}};
	bool service_exposed_{false};
	unique_ptr<DiscoveredPeer> peer_;
	};

	TEST_F(DiscoveredPeerTest, CanUpdateFromAdvertisement) {
	peer_->UpdateFromAdvertisement(kNewName, kNewNote,
	Time::FromTimeT(kNewPeerLastSeen),
	kFakeTech1);
	EXPECT_EQ(kNewName, peer_->GetFriendlyName());
	EXPECT_EQ(kNewNote, peer_->GetNote());
	EXPECT_EQ(Time::FromTimeT(kNewPeerLastSeen), peer_->GetLastSeen());
	EXPECT_EQ(1, peer_->GetTechnologyCount());
	}

	TEST_F(DiscoveredPeerTest, CannotUpdateFromInvalidAdvertisement) {
	peer_->UpdateFromAdvertisement(kBadName, kNewNote,
	Time::FromTimeT(kNewPeerLastSeen),
	kFakeTech1);
	ExpectInitialPeerValues();
	}

	TEST_F(DiscoveredPeerTest, CannotPartiallyUpdatePeer) {
	// Only invalid note.
	peer_->UpdateFromAdvertisement(kNewName, kBadNote,
	Time::FromTimeT(kNewPeerLastSeen),
	kFakeTech1);
	ExpectInitialPeerValues();
	// Only invalid name.
	peer_->UpdateFromAdvertisement(kBadName, kNewNote,
	Time::FromTimeT(kNewPeerLastSeen),
	kFakeTech1);
	ExpectInitialPeerValues();
	// Stale advertisement.
	peer_->UpdateFromAdvertisement(kNewName, kNewNote,
	Time::FromTimeT(kStalePeerLastSeen),
	kFakeTech1);
	ExpectInitialPeerValues();
	}

	TEST_F(DiscoveredPeerTest, CanAddService) {
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech1);
	}

	TEST_F(DiscoveredPeerTest, CannotPartiallyAddService) {
	peer_->UpdateService(kBadServiceId, {}, {},
	Time::FromTimeT(kServiceLastSeen), kFakeTech1);
	ExpectNoServicesDiscovered();
	}

	TEST_F(DiscoveredPeerTest, CannotAddServiceForUnknownTechnology) {
	peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech2);
	}

	TEST_F(DiscoveredPeerTest, CanUpdateService) {
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {},
	Time::FromTimeT(kServiceLastSeen), kFakeTech1);
	const Service::ServiceInfo valid_info{{"good_key", "valid value"}};
	peer_->UpdateService(kServiceId, {}, valid_info,
	Time::FromTimeT(kServiceNewLastSeen), kFakeTech1);
	ExpectServiceHasValues(kServiceId, {}, valid_info,
	Time::FromTimeT(kServiceNewLastSeen),
	kFakeTech1);
	}

	TEST_F(DiscoveredPeerTest, CannotPartiallyUpdateService) {
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {},
	Time::FromTimeT(kServiceLastSeen), kFakeTech1);
	const Service::ServiceInfo invalid_info{{"#badkey", "valid value"}};
	peer_->UpdateService(kServiceId, {}, invalid_info,
	Time::FromTimeT(kServiceLastSeen), kFakeTech2);
	ExpectServiceHasValues(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech1);
	}

	TEST_F(DiscoveredPeerTest, ShouldRejectStaleServiceUpdate) {
	peer_->UpdateFromAdvertisement(kName, kNote,
	Time::FromTimeT(kPeerLastSeen),
	kFakeTech2);
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {},
	Time::FromTimeT(kServiceLastSeen), kFakeTech1);
	const Service::ServiceInfo valid_info{{"good_key", "valid value"}};
	peer_->UpdateService(kServiceId, {}, valid_info,
	Time::FromTimeT(kServiceStaleLastSeen), kFakeTech2);
	ExpectServiceHasValues(kServiceId, {}, {},
	Time::FromTimeT(kServiceLastSeen), kFakeTech1);
	}

	TEST_F(DiscoveredPeerTest, RemoveTechnologyIsRecursive) {
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech1);
	ExpectServiceRemoved();
	peer_->RemoveTechnology(kFakeTech1);
	}

	TEST_F(DiscoveredPeerTest, HandlesMultipleTechnologies) {
	peer_->UpdateFromAdvertisement(kNewName, kNewNote,
	Time::FromTimeT(kNewPeerLastSeen),
	kFakeTech2);
	EXPECT_EQ(2, peer_->GetTechnologyCount());
	ExpectServiceExposed();
	peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech1);
	// This should not create a new service object, just touch the existing one.
	peer_->UpdateService(kServiceId, {}, {}, Time::FromTimeT(kServiceLastSeen),
	kFakeTech2);
	peer_->RemoveTechnology(kFakeTech2);
	EXPECT_EQ(1, peer_->GetTechnologyCount());
	ExpectServiceRemoved();
	peer_->RemoveTechnologyFromService(kServiceId, kFakeTech1);
	}

	} // namespace peerd