leaderd/group_unittest.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2015 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 <string>

 #include <base/message_loop/message_loop.h>
 #include <base/run_loop.h>
 #include <base/timer/mock_timer.h>
 #include <chromeos/mime_utils.h>
 #include <chromeos/http/http_transport_fake.h>
 #include <dbus/bus.h>
 #include <dbus/mock_bus.h>
 #include <dbus/mock_exported_object.h>
 #include <dbus/object_path.h>
 #include <gtest/gtest.h>

 #include "leaderd/group.h"
 #include "leaderd/manager.h"

 using base::MockTimer;
 using base::Timer;
 using chromeos::dbus_utils::ExportedObjectManager;
 using dbus::MockBus;
 using dbus::MockExportedObject;
 using dbus::ObjectPath;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::ReturnRef;
 using testing::_;

 namespace leaderd {

 namespace {

 const char kObjectManagerPath[] = "/objman";
 const char kGroupPath[] = "/objman/group";
 const char kGroupName[] = "ABC";
 const char kScore = 25;
 const char kTestDBusSource[] = "TestDBusSource";
 const char kSelfUUID[] = "this is my own uuid";
 const int32_t kSelfScore = 100;
 const char kPeerIdLessThanSelf[] = "a peer id that is less than self";
 const char kPeerIdGreaterThanSelf[] = "wow, an id that is greater than self";

 const char kTestGroupMember[] = "a peer that could be in our group";
 const uint16_t kTestGroupMemberPort{8080};
 const uint8_t kTestGroupMemberOctetValue{10};
 const char kTestGroupMemberChallengeUrl[] =
     "http://10.10.10.10:8080/privet/v3/leadership/challenge";
 const char kTestGroupMemberAnnounceUrl[] =
     "http://10.10.10.10:8080/privet/v3/leadership/announce";

 // Chrome doesn't bother mocking out their objects completely.
 class EspeciallyMockedBus : public dbus::MockBus {
  public:
   using dbus::MockBus::MockBus;

   MOCK_METHOD2(GetServiceOwner, void(const std::string& service_name,
                                      const GetServiceOwnerCallback& callback));

   MOCK_METHOD2(ListenForServiceOwnerChange,
                void(const std::string& service_name,
                     const GetServiceOwnerCallback& callback));

   MOCK_METHOD2(UnlistenForServiceOwnerChange,
                void(const std::string& service_name,
                     const GetServiceOwnerCallback& callback));

  protected:
   virtual ~EspeciallyMockedBus() = default;
 };

 std::vector<std::tuple<std::vector<uint8_t>, uint16_t>> ReturnsFakeIpInfo(
         const std::string& peer_uuid) {
   using PeerIp = std::vector<uint8_t>;
   using PeerAddress = std::tuple<PeerIp, uint16_t>;
   PeerAddress peer_ip{PeerIp(4, kTestGroupMemberOctetValue),
                       kTestGroupMemberPort};
   return std::vector<PeerAddress>{peer_ip};
 }

 class MockGroupDelegate : public Group::Delegate {
  public:
   MockGroupDelegate() {
     EXPECT_CALL(*this, GetUUID()).WillRepeatedly(ReturnRef(uuid_));
     EXPECT_CALL(*this, GetIPInfo(kTestGroupMember))
       .WillRepeatedly(Invoke(&ReturnsFakeIpInfo));
   }

   MOCK_CONST_METHOD0(GetUUID, const std::string&());
   MOCK_METHOD1(RemoveGroup, void(const std::string&));
   MOCK_CONST_METHOD1(GetIPInfo,
                      std::vector<std::tuple<std::vector<uint8_t>, uint16_t>>(
                          const std::string&));

   // The delegate makes us return a reference, not a value.
   const std::string uuid_{kSelfUUID};
 };

 void HandlerNotFound(const chromeos::http::fake::ServerRequest&,
                      chromeos::http::fake::ServerResponse* response) {
   response->ReplyText(404, std::string{}, chromeos::mime::text::kPlain);
 }

 class FakePeerHttpHandler {
  public:
   FakePeerHttpHandler(
       std::shared_ptr<chromeos::http::fake::Transport> transport) {
     transport->AddHandler(
         kTestGroupMemberChallengeUrl, chromeos::http::request_type::kPost,
         base::Bind(&FakePeerHttpHandler::HandleChallenge,
                    weak_ptr_factory_.GetWeakPtr()));
     transport->AddHandler(
         kTestGroupMemberAnnounceUrl, chromeos::http::request_type::kPost,
         base::Bind(&FakePeerHttpHandler::HandleAnnouncement,
                    weak_ptr_factory_.GetWeakPtr()));

     // By default, let everything go.
     EXPECT_CALL(*this, HandleAnnouncement(_, _)).Times(AnyNumber());
     EXPECT_CALL(*this, HandleChallenge(_, _)).Times(AnyNumber());
   }

   MOCK_METHOD2(HandleAnnouncement,
                void(const chromeos::http::fake::ServerRequest&,
                     chromeos::http::fake::ServerResponse*));
   MOCK_METHOD2(HandleChallenge,
                void(const chromeos::http::fake::ServerRequest&,
                     chromeos::http::fake::ServerResponse*));

  private:
   base::WeakPtrFactory<FakePeerHttpHandler> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(FakePeerHttpHandler);
 };

 void AssertChallengeWellFormed(
     const chromeos::http::fake::ServerRequest& request,
     chromeos::http::fake::ServerResponse*) {
   ASSERT_EQ(request.GetURL(), kTestGroupMemberChallengeUrl);
   ASSERT_EQ(request.GetMethod(), chromeos::http::request_type::kPost);
   int score;
   std::string str_field;
   auto json_dict = request.GetDataAsJson();
   ASSERT_NE(json_dict.get(), nullptr);
   ASSERT_EQ(json_dict->size(), 3);
   ASSERT_TRUE(json_dict->GetString(http_api::kChallengeGroupKey, &str_field));
   ASSERT_TRUE(json_dict->GetString(http_api::kChallengeIdKey, &str_field));
   ASSERT_TRUE(json_dict->GetInteger(http_api::kChallengeScoreKey, &score));
 }

 void AssertAnnouncementWellFormed(
     const chromeos::http::fake::ServerRequest& request,
     chromeos::http::fake::ServerResponse*) {
   ASSERT_EQ(request.GetURL(), kTestGroupMemberAnnounceUrl);
   ASSERT_EQ(request.GetMethod(), chromeos::http::request_type::kPost);
   int score;
   std::string str_field;
   auto json_dict = request.GetDataAsJson();
   ASSERT_NE(json_dict.get(), nullptr);
   ASSERT_EQ(json_dict->size(), 3);
   ASSERT_TRUE(json_dict->GetString(http_api::kAnnounceGroupKey, &str_field));
   ASSERT_TRUE(json_dict->GetString(http_api::kAnnounceLeaderIdKey, &str_field));
   ASSERT_TRUE(json_dict->GetInteger(http_api::kAnnounceScoreKey, &score));
 }

 }  // namespace

 class GroupTest : public testing::Test {
  public:
   void SetUp() override {
     // Ignore threading concerns.
     EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, ListenForServiceOwnerChange(kTestDBusSource, _));
     EXPECT_CALL(*bus_, GetServiceOwner(kTestDBusSource, _));

     group_.reset(new Group{kGroupName,
                            std::unique_ptr<GroupConfig>{new GroupConfig()},
                            bus_,
                            object_manager_.get(),
                            dbus::ObjectPath(kGroupPath),
                            kTestDBusSource,
                            {},
                            &group_delegate_});
     wanderer_timer_ = new MockTimer{false, false};
     heartbeat_timer_ = new MockTimer{true, true};
     group_->ReplaceTimersWithMocksForTest(
         std::unique_ptr<Timer>{wanderer_timer_},
         std::unique_ptr<Timer>{heartbeat_timer_});
     group_->ReplaceHTTPTransportForTest(transport_);
   }

   void AssertState(Group::State state, const std::string& leader_id) {
     EXPECT_EQ(state, group_->state_);
     EXPECT_EQ(leader_id, group_->leader_);
   }

   void SetRole(Group::State state, const std::string& leader_id) {
     group_->SetRole(state, leader_id);
   }

   base::MessageLoop message_loop_;
   scoped_refptr<EspeciallyMockedBus> bus_{
       new EspeciallyMockedBus{dbus::Bus::Options{}}};
   std::unique_ptr<ExportedObjectManager> object_manager_{
       new ExportedObjectManager(bus_,
                                 dbus::ObjectPath(kObjectManagerPath))};
   MockGroupDelegate group_delegate_;
   std::unique_ptr<Group> group_;
   // We'll fill these in at SetUp time, but the timers are owned by the Group.
   MockTimer* wanderer_timer_{nullptr};
   MockTimer* heartbeat_timer_{nullptr};
   std::shared_ptr<chromeos::http::fake::Transport> transport_{
       new chromeos::http::fake::Transport()};
   std::unique_ptr<FakePeerHttpHandler> fake_handler_{
       new FakePeerHttpHandler{transport_}};
 };

 TEST_F(GroupTest, LeaveGroup) {
   chromeos::ErrorPtr error;
   EXPECT_TRUE(group_->LeaveGroup(&error));
   EXPECT_EQ(nullptr, error.get());
 }

 TEST_F(GroupTest, SetScore) {
   chromeos::ErrorPtr error;
   LOG(INFO) << "Set score";
   EXPECT_TRUE(group_->SetScore(&error, kScore));
   EXPECT_EQ(nullptr, error.get());
 }

 TEST_F(GroupTest, ShouldBecomeLeaderWithoutPeers) {
   SetRole(Group::State::WANDERER, "");
   // A couple heartbearts in wanderer state should change
   // nothing if we don't have any peers.
   heartbeat_timer_->Fire();
   AssertState(Group::State::WANDERER, "");
   heartbeat_timer_->Fire();
   AssertState(Group::State::WANDERER, "");
   // And if nothing happens for long enough, we should promote
   // ourselves to leader.
   wanderer_timer_->Fire();
   AssertState(Group::State::LEADER, kSelfUUID);
 }

 TEST_F(GroupTest, ShouldIgnoreAnnouncementsFromUnknownPeers) {
   group_->AddPeer(kTestGroupMember);
   // Ignore spurious announcements in wanderer.
   SetRole(Group::State::WANDERER, "");
   group_->HandleLeaderAnnouncement("a peer we've never heard of", 100);
   AssertState(Group::State::WANDERER, "");
   // Ignore spurious announcements in leader.
   SetRole(Group::State::LEADER, kSelfUUID);
   group_->HandleLeaderAnnouncement("another strange peer", 100);
   AssertState(Group::State::LEADER, kSelfUUID);
 }

 TEST_F(GroupTest, BecomesFollowerOnAnnouncementWhileWanderer) {
   group_->AddPeer(kTestGroupMember);
   SetRole(Group::State::WANDERER, "");
   group_->HandleLeaderAnnouncement(kTestGroupMember, 100);
   AssertState(Group::State::FOLLOWER, kTestGroupMember);
 }

 TEST_F(GroupTest, BecomesWandererOnAnnouncementWhileLeader) {
   group_->AddPeer(kTestGroupMember);
   SetRole(Group::State::LEADER, kSelfUUID);
   group_->HandleLeaderAnnouncement(kTestGroupMember, 100);
   AssertState(Group::State::WANDERER, "");
 }

 TEST_F(GroupTest, LeaderChallengeIsWellFormed) {
   transport_->AddHandler(kTestGroupMemberChallengeUrl,
                          chromeos::http::request_type::kPost,
                          base::Bind(&AssertChallengeWellFormed));
   group_->SendLeaderChallenge(kTestGroupMember);
 }

 TEST_F(GroupTest, LeaderAnnouncementIsWellFormed) {
   transport_->AddHandler(kTestGroupMemberAnnounceUrl,
                          chromeos::http::request_type::kPost,
                          base::Bind(&AssertAnnouncementWellFormed));
   group_->SendLeaderAnnouncement(kTestGroupMember);
 }

 TEST_F(GroupTest, SendsAnnouncementsPeriodicallyWhenLeader) {
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   group_->AddPeer(kTestGroupMember);
   // We'll announce our leadership immediately on assuming the role.
   EXPECT_CALL(*fake_handler_, HandleAnnouncement(_, _));
   SetRole(Group::State::LEADER, kSelfUUID);
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   // We'll also announce periodically, on the heartbeat timer.
   EXPECT_CALL(*fake_handler_, HandleAnnouncement(_, _));
   heartbeat_timer_->Fire();
 }

 TEST_F(GroupTest, SendsChallengesPeriodicallyWhenFollower) {
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   group_->AddPeer(kTestGroupMember);
   SetRole(Group::State::FOLLOWER, kTestGroupMember);
   // On every heartbeat, we should challenge the leader.
   EXPECT_CALL(*fake_handler_, HandleChallenge(_, _)).Times(2);
   heartbeat_timer_->Fire();
   heartbeat_timer_->Fire();
 }

 TEST_F(GroupTest, IgnoresChallengesWhileNotLeader) {
   std::string leader_id, self_id;
   group_->AddPeer(kTestGroupMember);
   // When we're following, we basically ignores scores, and just return what we
   // know about the leader.
   SetRole(Group::State::FOLLOWER, kTestGroupMember);
   group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
                                 kSelfScore + 1,
                                 &leader_id, &self_id);
   ASSERT_EQ(kTestGroupMember, leader_id);
   AssertState(Group::State::FOLLOWER, kTestGroupMember);
   // In wanderer, the same applies.
   SetRole(Group::State::WANDERER, std::string{});
   group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
                                 kSelfScore + 1,
                                 &leader_id, &self_id);
   ASSERT_EQ(std::string{}, leader_id);
   AssertState(Group::State::WANDERER, std::string{});
 }

 TEST_F(GroupTest, ShouldRetainLeadershipWhenMoreFit) {
   std::string leader_id, self_id;
   SetRole(Group::State::LEADER, kSelfUUID);
   group_->SetScore(nullptr, kSelfScore);
   // If the challenger score is less, we should ignore the peer ID.
   group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
                                 kSelfScore - 1,
                                 &leader_id, &self_id);
   AssertState(Group::State::LEADER, kSelfUUID);
   ASSERT_EQ(kSelfUUID, leader_id);
   // If the challenger score is equal, we check the peer ID.
   group_->HandleLeaderChallenge(kPeerIdLessThanSelf,
                                 kSelfScore,
                                 &leader_id, &self_id);
   AssertState(Group::State::LEADER, kSelfUUID);
   ASSERT_EQ(kSelfUUID, leader_id);
 }

 TEST_F(GroupTest, ShouldAbdicateToPeerWithHigherScore) {
   std::string leader_id, self_id;
   SetRole(Group::State::LEADER, kSelfUUID);
   group_->SetScore(nullptr, kSelfScore);
   group_->HandleLeaderChallenge(kPeerIdLessThanSelf,
                                 kSelfScore + 1,
                                 &leader_id, &self_id);
   AssertState(Group::State::FOLLOWER, kPeerIdLessThanSelf);
   ASSERT_EQ(kPeerIdLessThanSelf, leader_id);
 }

 TEST_F(GroupTest, ShouldAbdicateToPeerWithHigherID) {
   std::string leader_id, self_id;
   SetRole(Group::State::LEADER, kSelfUUID);
   group_->SetScore(nullptr, kSelfScore);
   group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
                                 kSelfScore,
                                 &leader_id, &self_id);
   AssertState(Group::State::FOLLOWER, kPeerIdGreaterThanSelf);
   ASSERT_EQ(kPeerIdGreaterThanSelf, leader_id);
 }

 TEST_F(GroupTest, MayOnlyPokeLeaderWhenFollowing) {
   group_->AddPeer(kTestGroupMember);
   chromeos::ErrorPtr error;
   // We only allow ourselves to poke the leader if we're actually following
   // a leader.
   SetRole(Group::State::LEADER, kSelfUUID);
   EXPECT_FALSE(group_->PokeLeader(&error));
   EXPECT_NE(nullptr, error.get());
   error.reset();
   SetRole(Group::State::WANDERER, std::string{});
   EXPECT_FALSE(group_->PokeLeader(&error));
   EXPECT_NE(nullptr, error.get());
   error.reset();
   // Check that we do actually challenge the leader when poked.
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   EXPECT_CALL(*fake_handler_, HandleChallenge(_, _));
   SetRole(Group::State::FOLLOWER, kTestGroupMember);
   EXPECT_TRUE(group_->PokeLeader(&error));
   EXPECT_EQ(nullptr, error.get());
 }

 TEST_F(GroupTest, BecomesWandererOnLeaderFailure) {
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   group_->AddPeer(kTestGroupMember);
   SetRole(Group::State::FOLLOWER, kTestGroupMember);
   // On every heartbeat, we should challenge the leader.
   EXPECT_CALL(*fake_handler_, HandleChallenge(_, _)).Times(2)
       .WillRepeatedly(Invoke(&HandlerNotFound));
   heartbeat_timer_->Fire();
   heartbeat_timer_->Fire();
   AssertState(Group::State::WANDERER, std::string{});
 }

 TEST_F(GroupTest, ShouldChallengeOnScoreIncreaseWhenFollower) {
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   group_->AddPeer(kTestGroupMember);
   group_->SetScore(nullptr, 0);
   SetRole(Group::State::FOLLOWER, kTestGroupMember);
   EXPECT_CALL(*fake_handler_, HandleChallenge(_, _));
   group_->SetScore(nullptr, 10);
   testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
   // If we're not a follower, we should not attempt to challenge a leader.
   SetRole(Group::State::WANDERER, std::string{});
   group_->SetScore(nullptr, 20);
 }

 }  // namespace leaderd
	// Copyright 2015 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 <string>

	#include <base/message_loop/message_loop.h>
	#include <base/run_loop.h>
	#include <base/timer/mock_timer.h>
	#include <chromeos/mime_utils.h>
	#include <chromeos/http/http_transport_fake.h>
	#include <dbus/bus.h>
	#include <dbus/mock_bus.h>
	#include <dbus/mock_exported_object.h>
	#include <dbus/object_path.h>
	#include <gtest/gtest.h>

	#include "leaderd/group.h"
	#include "leaderd/manager.h"

	using base::MockTimer;
	using base::Timer;
	using chromeos::dbus_utils::ExportedObjectManager;
	using dbus::MockBus;
	using dbus::MockExportedObject;
	using dbus::ObjectPath;
	using testing::AnyNumber;
	using testing::Invoke;
	using testing::ReturnRef;
	using testing::_;

	namespace leaderd {

	namespace {

	const char kObjectManagerPath[] = "/objman";
	const char kGroupPath[] = "/objman/group";
	const char kGroupName[] = "ABC";
	const char kScore = 25;
	const char kTestDBusSource[] = "TestDBusSource";
	const char kSelfUUID[] = "this is my own uuid";
	const int32_t kSelfScore = 100;
	const char kPeerIdLessThanSelf[] = "a peer id that is less than self";
	const char kPeerIdGreaterThanSelf[] = "wow, an id that is greater than self";

	const char kTestGroupMember[] = "a peer that could be in our group";
	const uint16_t kTestGroupMemberPort{8080};
	const uint8_t kTestGroupMemberOctetValue{10};
	const char kTestGroupMemberChallengeUrl[] =
	"http://10.10.10.10:8080/privet/v3/leadership/challenge";
	const char kTestGroupMemberAnnounceUrl[] =
	"http://10.10.10.10:8080/privet/v3/leadership/announce";

	// Chrome doesn't bother mocking out their objects completely.
	class EspeciallyMockedBus : public dbus::MockBus {
	public:
	using dbus::MockBus::MockBus;

	MOCK_METHOD2(GetServiceOwner, void(const std::string& service_name,
	const GetServiceOwnerCallback& callback));

	MOCK_METHOD2(ListenForServiceOwnerChange,
	void(const std::string& service_name,
	const GetServiceOwnerCallback& callback));

	MOCK_METHOD2(UnlistenForServiceOwnerChange,
	void(const std::string& service_name,
	const GetServiceOwnerCallback& callback));

	protected:
	virtual ~EspeciallyMockedBus() = default;
	};

	std::vector<std::tuple<std::vector<uint8_t>, uint16_t>> ReturnsFakeIpInfo(
	const std::string& peer_uuid) {
	using PeerIp = std::vector<uint8_t>;
	using PeerAddress = std::tuple<PeerIp, uint16_t>;
	PeerAddress peer_ip{PeerIp(4, kTestGroupMemberOctetValue),
	kTestGroupMemberPort};
	return std::vector<PeerAddress>{peer_ip};
	}

	class MockGroupDelegate : public Group::Delegate {
	public:
	MockGroupDelegate() {
	EXPECT_CALL(*this, GetUUID()).WillRepeatedly(ReturnRef(uuid_));
	EXPECT_CALL(*this, GetIPInfo(kTestGroupMember))
	.WillRepeatedly(Invoke(&ReturnsFakeIpInfo));
	}

	MOCK_CONST_METHOD0(GetUUID, const std::string&());
	MOCK_METHOD1(RemoveGroup, void(const std::string&));
	MOCK_CONST_METHOD1(GetIPInfo,
	std::vector<std::tuple<std::vector<uint8_t>, uint16_t>>(
	const std::string&));

	// The delegate makes us return a reference, not a value.
	const std::string uuid_{kSelfUUID};
	};

	void HandlerNotFound(const chromeos::http::fake::ServerRequest&,
	chromeos::http::fake::ServerResponse* response) {
	response->ReplyText(404, std::string{}, chromeos::mime::text::kPlain);
	}

	class FakePeerHttpHandler {
	public:
	FakePeerHttpHandler(
	std::shared_ptr<chromeos::http::fake::Transport> transport) {
	transport->AddHandler(
	kTestGroupMemberChallengeUrl, chromeos::http::request_type::kPost,
	base::Bind(&FakePeerHttpHandler::HandleChallenge,
	weak_ptr_factory_.GetWeakPtr()));
	transport->AddHandler(
	kTestGroupMemberAnnounceUrl, chromeos::http::request_type::kPost,
	base::Bind(&FakePeerHttpHandler::HandleAnnouncement,
	weak_ptr_factory_.GetWeakPtr()));

	// By default, let everything go.
	EXPECT_CALL(*this, HandleAnnouncement(_, _)).Times(AnyNumber());
	EXPECT_CALL(*this, HandleChallenge(_, _)).Times(AnyNumber());
	}

	MOCK_METHOD2(HandleAnnouncement,
	void(const chromeos::http::fake::ServerRequest&,
	chromeos::http::fake::ServerResponse*));
	MOCK_METHOD2(HandleChallenge,
	void(const chromeos::http::fake::ServerRequest&,
	chromeos::http::fake::ServerResponse*));

	private:
	base::WeakPtrFactory<FakePeerHttpHandler> weak_ptr_factory_{this};
	DISALLOW_COPY_AND_ASSIGN(FakePeerHttpHandler);
	};

	void AssertChallengeWellFormed(
	const chromeos::http::fake::ServerRequest& request,
	chromeos::http::fake::ServerResponse*) {
	ASSERT_EQ(request.GetURL(), kTestGroupMemberChallengeUrl);
	ASSERT_EQ(request.GetMethod(), chromeos::http::request_type::kPost);
	int score;
	std::string str_field;
	auto json_dict = request.GetDataAsJson();
	ASSERT_NE(json_dict.get(), nullptr);
	ASSERT_EQ(json_dict->size(), 3);
	ASSERT_TRUE(json_dict->GetString(http_api::kChallengeGroupKey, &str_field));
	ASSERT_TRUE(json_dict->GetString(http_api::kChallengeIdKey, &str_field));
	ASSERT_TRUE(json_dict->GetInteger(http_api::kChallengeScoreKey, &score));
	}

	void AssertAnnouncementWellFormed(
	const chromeos::http::fake::ServerRequest& request,
	chromeos::http::fake::ServerResponse*) {
	ASSERT_EQ(request.GetURL(), kTestGroupMemberAnnounceUrl);
	ASSERT_EQ(request.GetMethod(), chromeos::http::request_type::kPost);
	int score;
	std::string str_field;
	auto json_dict = request.GetDataAsJson();
	ASSERT_NE(json_dict.get(), nullptr);
	ASSERT_EQ(json_dict->size(), 3);
	ASSERT_TRUE(json_dict->GetString(http_api::kAnnounceGroupKey, &str_field));
	ASSERT_TRUE(json_dict->GetString(http_api::kAnnounceLeaderIdKey, &str_field));
	ASSERT_TRUE(json_dict->GetInteger(http_api::kAnnounceScoreKey, &score));
	}

	} // namespace

	class GroupTest : public testing::Test {
	public:
	void SetUp() override {
	// Ignore threading concerns.
	EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
	EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
	EXPECT_CALL(*bus_, ListenForServiceOwnerChange(kTestDBusSource, _));
	EXPECT_CALL(*bus_, GetServiceOwner(kTestDBusSource, _));

	group_.reset(new Group{kGroupName,
	std::unique_ptr<GroupConfig>{new GroupConfig()},
	bus_,
	object_manager_.get(),
	dbus::ObjectPath(kGroupPath),
	kTestDBusSource,
	{},
	&group_delegate_});
	wanderer_timer_ = new MockTimer{false, false};
	heartbeat_timer_ = new MockTimer{true, true};
	group_->ReplaceTimersWithMocksForTest(
	std::unique_ptr<Timer>{wanderer_timer_},
	std::unique_ptr<Timer>{heartbeat_timer_});
	group_->ReplaceHTTPTransportForTest(transport_);
	}

	void AssertState(Group::State state, const std::string& leader_id) {
	EXPECT_EQ(state, group_->state_);
	EXPECT_EQ(leader_id, group_->leader_);
	}

	void SetRole(Group::State state, const std::string& leader_id) {
	group_->SetRole(state, leader_id);
	}

	base::MessageLoop message_loop_;
	scoped_refptr<EspeciallyMockedBus> bus_{
	new EspeciallyMockedBus{dbus::Bus::Options{}}};
	std::unique_ptr<ExportedObjectManager> object_manager_{
	new ExportedObjectManager(bus_,
	dbus::ObjectPath(kObjectManagerPath))};
	MockGroupDelegate group_delegate_;
	std::unique_ptr<Group> group_;
	// We'll fill these in at SetUp time, but the timers are owned by the Group.
	MockTimer* wanderer_timer_{nullptr};
	MockTimer* heartbeat_timer_{nullptr};
	std::shared_ptr<chromeos::http::fake::Transport> transport_{
	new chromeos::http::fake::Transport()};
	std::unique_ptr<FakePeerHttpHandler> fake_handler_{
	new FakePeerHttpHandler{transport_}};
	};

	TEST_F(GroupTest, LeaveGroup) {
	chromeos::ErrorPtr error;
	EXPECT_TRUE(group_->LeaveGroup(&error));
	EXPECT_EQ(nullptr, error.get());
	}

	TEST_F(GroupTest, SetScore) {
	chromeos::ErrorPtr error;
	LOG(INFO) << "Set score";
	EXPECT_TRUE(group_->SetScore(&error, kScore));
	EXPECT_EQ(nullptr, error.get());
	}

	TEST_F(GroupTest, ShouldBecomeLeaderWithoutPeers) {
	SetRole(Group::State::WANDERER, "");
	// A couple heartbearts in wanderer state should change
	// nothing if we don't have any peers.
	heartbeat_timer_->Fire();
	AssertState(Group::State::WANDERER, "");
	heartbeat_timer_->Fire();
	AssertState(Group::State::WANDERER, "");
	// And if nothing happens for long enough, we should promote
	// ourselves to leader.
	wanderer_timer_->Fire();
	AssertState(Group::State::LEADER, kSelfUUID);
	}

	TEST_F(GroupTest, ShouldIgnoreAnnouncementsFromUnknownPeers) {
	group_->AddPeer(kTestGroupMember);
	// Ignore spurious announcements in wanderer.
	SetRole(Group::State::WANDERER, "");
	group_->HandleLeaderAnnouncement("a peer we've never heard of", 100);
	AssertState(Group::State::WANDERER, "");
	// Ignore spurious announcements in leader.
	SetRole(Group::State::LEADER, kSelfUUID);
	group_->HandleLeaderAnnouncement("another strange peer", 100);
	AssertState(Group::State::LEADER, kSelfUUID);
	}

	TEST_F(GroupTest, BecomesFollowerOnAnnouncementWhileWanderer) {
	group_->AddPeer(kTestGroupMember);
	SetRole(Group::State::WANDERER, "");
	group_->HandleLeaderAnnouncement(kTestGroupMember, 100);
	AssertState(Group::State::FOLLOWER, kTestGroupMember);
	}

	TEST_F(GroupTest, BecomesWandererOnAnnouncementWhileLeader) {
	group_->AddPeer(kTestGroupMember);
	SetRole(Group::State::LEADER, kSelfUUID);
	group_->HandleLeaderAnnouncement(kTestGroupMember, 100);
	AssertState(Group::State::WANDERER, "");
	}

	TEST_F(GroupTest, LeaderChallengeIsWellFormed) {
	transport_->AddHandler(kTestGroupMemberChallengeUrl,
	chromeos::http::request_type::kPost,
	base::Bind(&AssertChallengeWellFormed));
	group_->SendLeaderChallenge(kTestGroupMember);
	}

	TEST_F(GroupTest, LeaderAnnouncementIsWellFormed) {
	transport_->AddHandler(kTestGroupMemberAnnounceUrl,
	chromeos::http::request_type::kPost,
	base::Bind(&AssertAnnouncementWellFormed));
	group_->SendLeaderAnnouncement(kTestGroupMember);
	}

	TEST_F(GroupTest, SendsAnnouncementsPeriodicallyWhenLeader) {
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	group_->AddPeer(kTestGroupMember);
	// We'll announce our leadership immediately on assuming the role.
	EXPECT_CALL(*fake_handler_, HandleAnnouncement(_, _));
	SetRole(Group::State::LEADER, kSelfUUID);
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	// We'll also announce periodically, on the heartbeat timer.
	EXPECT_CALL(*fake_handler_, HandleAnnouncement(_, _));
	heartbeat_timer_->Fire();
	}

	TEST_F(GroupTest, SendsChallengesPeriodicallyWhenFollower) {
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	group_->AddPeer(kTestGroupMember);
	SetRole(Group::State::FOLLOWER, kTestGroupMember);
	// On every heartbeat, we should challenge the leader.
	EXPECT_CALL(*fake_handler_, HandleChallenge(_, _)).Times(2);
	heartbeat_timer_->Fire();
	heartbeat_timer_->Fire();
	}

	TEST_F(GroupTest, IgnoresChallengesWhileNotLeader) {
	std::string leader_id, self_id;
	group_->AddPeer(kTestGroupMember);
	// When we're following, we basically ignores scores, and just return what we
	// know about the leader.
	SetRole(Group::State::FOLLOWER, kTestGroupMember);
	group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
	kSelfScore + 1,
	&leader_id, &self_id);
	ASSERT_EQ(kTestGroupMember, leader_id);
	AssertState(Group::State::FOLLOWER, kTestGroupMember);
	// In wanderer, the same applies.
	SetRole(Group::State::WANDERER, std::string{});
	group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
	kSelfScore + 1,
	&leader_id, &self_id);
	ASSERT_EQ(std::string{}, leader_id);
	AssertState(Group::State::WANDERER, std::string{});
	}

	TEST_F(GroupTest, ShouldRetainLeadershipWhenMoreFit) {
	std::string leader_id, self_id;
	SetRole(Group::State::LEADER, kSelfUUID);
	group_->SetScore(nullptr, kSelfScore);
	// If the challenger score is less, we should ignore the peer ID.
	group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
	kSelfScore - 1,
	&leader_id, &self_id);
	AssertState(Group::State::LEADER, kSelfUUID);
	ASSERT_EQ(kSelfUUID, leader_id);
	// If the challenger score is equal, we check the peer ID.
	group_->HandleLeaderChallenge(kPeerIdLessThanSelf,
	kSelfScore,
	&leader_id, &self_id);
	AssertState(Group::State::LEADER, kSelfUUID);
	ASSERT_EQ(kSelfUUID, leader_id);
	}

	TEST_F(GroupTest, ShouldAbdicateToPeerWithHigherScore) {
	std::string leader_id, self_id;
	SetRole(Group::State::LEADER, kSelfUUID);
	group_->SetScore(nullptr, kSelfScore);
	group_->HandleLeaderChallenge(kPeerIdLessThanSelf,
	kSelfScore + 1,
	&leader_id, &self_id);
	AssertState(Group::State::FOLLOWER, kPeerIdLessThanSelf);
	ASSERT_EQ(kPeerIdLessThanSelf, leader_id);
	}

	TEST_F(GroupTest, ShouldAbdicateToPeerWithHigherID) {
	std::string leader_id, self_id;
	SetRole(Group::State::LEADER, kSelfUUID);
	group_->SetScore(nullptr, kSelfScore);
	group_->HandleLeaderChallenge(kPeerIdGreaterThanSelf,
	kSelfScore,
	&leader_id, &self_id);
	AssertState(Group::State::FOLLOWER, kPeerIdGreaterThanSelf);
	ASSERT_EQ(kPeerIdGreaterThanSelf, leader_id);
	}

	TEST_F(GroupTest, MayOnlyPokeLeaderWhenFollowing) {
	group_->AddPeer(kTestGroupMember);
	chromeos::ErrorPtr error;
	// We only allow ourselves to poke the leader if we're actually following
	// a leader.
	SetRole(Group::State::LEADER, kSelfUUID);
	EXPECT_FALSE(group_->PokeLeader(&error));
	EXPECT_NE(nullptr, error.get());
	error.reset();
	SetRole(Group::State::WANDERER, std::string{});
	EXPECT_FALSE(group_->PokeLeader(&error));
	EXPECT_NE(nullptr, error.get());
	error.reset();
	// Check that we do actually challenge the leader when poked.
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	EXPECT_CALL(*fake_handler_, HandleChallenge(_, _));
	SetRole(Group::State::FOLLOWER, kTestGroupMember);
	EXPECT_TRUE(group_->PokeLeader(&error));
	EXPECT_EQ(nullptr, error.get());
	}

	TEST_F(GroupTest, BecomesWandererOnLeaderFailure) {
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	group_->AddPeer(kTestGroupMember);
	SetRole(Group::State::FOLLOWER, kTestGroupMember);
	// On every heartbeat, we should challenge the leader.
	EXPECT_CALL(*fake_handler_, HandleChallenge(_, _)).Times(2)
	.WillRepeatedly(Invoke(&HandlerNotFound));
	heartbeat_timer_->Fire();
	heartbeat_timer_->Fire();
	AssertState(Group::State::WANDERER, std::string{});
	}

	TEST_F(GroupTest, ShouldChallengeOnScoreIncreaseWhenFollower) {
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	group_->AddPeer(kTestGroupMember);
	group_->SetScore(nullptr, 0);
	SetRole(Group::State::FOLLOWER, kTestGroupMember);
	EXPECT_CALL(*fake_handler_, HandleChallenge(_, _));
	group_->SetScore(nullptr, 10);
	testing::Mock::VerifyAndClearExpectations(fake_handler_.get());
	// If we're not a follower, we should not attempt to challenge a leader.
	SetRole(Group::State::WANDERER, std::string{});
	group_->SetScore(nullptr, 20);
	}

	} // namespace leaderd