blob: 5338e1bd83161948c6f011e9129a8a04cab79d7c [file] [log] [blame]
// Copyright 2015 The Weave Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef LIBWEAVE_SRC_PRIVET_MOCK_DELEGATES_H_
#define LIBWEAVE_SRC_PRIVET_MOCK_DELEGATES_H_
#include <set>
#include <string>
#include <utility>
#include <base/values.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "src/config.h"
#include "src/privet/cloud_delegate.h"
#include "src/privet/device_delegate.h"
#include "src/privet/security_delegate.h"
#include "src/privet/wifi_delegate.h"
using testing::_;
using testing::AtLeast;
using testing::Return;
using testing::ReturnRef;
using testing::SaveArg;
using testing::SetArgPointee;
namespace weave {
namespace privet {
struct TestUserId : public UserAppId {
TestUserId(const std::string& user_id)
: UserAppId{AuthType::kAnonymous, {user_id.begin(), user_id.end()}, {}} {}
};
ACTION_TEMPLATE(RunCallback,
HAS_1_TEMPLATE_PARAMS(int, k),
AND_0_VALUE_PARAMS()) {
return std::get<k>(args).Run();
}
ACTION_TEMPLATE(RunCallback,
HAS_1_TEMPLATE_PARAMS(int, k),
AND_1_VALUE_PARAMS(p0)) {
return std::get<k>(args).Run(p0);
}
class MockDeviceDelegate : public DeviceDelegate {
using IntPair = std::pair<uint16_t, uint16_t>;
public:
MOCK_CONST_METHOD0(GetHttpEnpoint, IntPair());
MOCK_CONST_METHOD0(GetHttpsEnpoint, IntPair());
MOCK_CONST_METHOD0(GetHttpRequestTimeout, base::TimeDelta());
MOCK_METHOD3(PostDelayedTask,
void(const tracked_objects::Location&,
const base::Closure&,
base::TimeDelta));
MockDeviceDelegate() {
EXPECT_CALL(*this, GetHttpEnpoint())
.WillRepeatedly(Return(std::make_pair(0, 0)));
EXPECT_CALL(*this, GetHttpsEnpoint())
.WillRepeatedly(Return(std::make_pair(0, 0)));
}
};
class MockSecurityDelegate : public SecurityDelegate {
public:
MOCK_METHOD7(CreateAccessToken,
bool(AuthType,
const std::string&,
AuthScope,
std::string*,
AuthScope*,
base::TimeDelta*,
ErrorPtr*));
MOCK_CONST_METHOD3(ParseAccessToken,
bool(const std::string&, UserInfo*, ErrorPtr*));
MOCK_CONST_METHOD0(GetPairingTypes, std::set<PairingType>());
MOCK_CONST_METHOD0(GetCryptoTypes, std::set<CryptoType>());
MOCK_CONST_METHOD0(GetAuthTypes, std::set<AuthType>());
MOCK_METHOD1(ClaimRootClientAuthToken, std::string(ErrorPtr*));
MOCK_METHOD2(ConfirmClientAuthToken, bool(const std::string&, ErrorPtr*));
MOCK_METHOD5(
StartPairing,
bool(PairingType, CryptoType, std::string*, std::string*, ErrorPtr*));
MOCK_METHOD5(ConfirmPairing,
bool(const std::string&,
const std::string&,
std::string*,
std::string*,
ErrorPtr*));
MOCK_METHOD2(CancelPairing, bool(const std::string&, ErrorPtr*));
MOCK_METHOD0(CreateSessionId, std::string());
MockSecurityDelegate() {
EXPECT_CALL(*this, CreateAccessToken(_, _, _, _, _, _, _))
.WillRepeatedly(DoAll(
SetArgPointee<3>("GuestAccessToken"),
SetArgPointee<4>(AuthScope::kViewer),
SetArgPointee<5>(base::TimeDelta::FromSeconds(15)), Return(true)));
EXPECT_CALL(*this, ClaimRootClientAuthToken(_))
.WillRepeatedly(Return("RootClientAuthToken"));
EXPECT_CALL(*this, ConfirmClientAuthToken("DerivedClientAuthToken", _))
.WillRepeatedly(Return(true));
EXPECT_CALL(*this, ParseAccessToken(_, _, _))
.WillRepeatedly(DoAll(SetArgPointee<1>(UserInfo{
AuthScope::kViewer,
UserAppId{AuthType::kLocal,
{'1', '2', '3', '4', '5', '6', '7'},
{}}}),
Return(true)));
EXPECT_CALL(*this, GetPairingTypes())
.WillRepeatedly(Return(std::set<PairingType>{
PairingType::kPinCode, PairingType::kEmbeddedCode,
}));
EXPECT_CALL(*this, GetCryptoTypes())
.WillRepeatedly(Return(std::set<CryptoType>{
CryptoType::kSpake_p224,
}));
EXPECT_CALL(*this, GetAuthTypes())
.WillRepeatedly(Return(std::set<AuthType>{
AuthType::kAnonymous, AuthType::kPairing, AuthType::kLocal,
}));
EXPECT_CALL(*this, StartPairing(_, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<2>("testSession"),
SetArgPointee<3>("testCommitment"),
Return(true)));
EXPECT_CALL(*this, ConfirmPairing(_, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<2>("testFingerprint"),
SetArgPointee<3>("testSignature"), Return(true)));
EXPECT_CALL(*this, CancelPairing(_, _)).WillRepeatedly(Return(true));
EXPECT_CALL(*this, CreateSessionId()).WillRepeatedly(Return("SessionId"));
}
};
class MockWifiDelegate : public WifiDelegate {
public:
MOCK_CONST_METHOD0(GetConnectionState, const ConnectionState&());
MOCK_CONST_METHOD0(GetSetupState, const SetupState&());
MOCK_METHOD3(ConfigureCredentials,
bool(const std::string&, const std::string&, ErrorPtr*));
MOCK_CONST_METHOD0(GetCurrentlyConnectedSsid, std::string());
MOCK_CONST_METHOD0(GetHostedSsid, std::string());
MOCK_CONST_METHOD0(GetTypes, std::set<WifiType>());
MockWifiDelegate() {
EXPECT_CALL(*this, GetConnectionState())
.WillRepeatedly(ReturnRef(connection_state_));
EXPECT_CALL(*this, GetSetupState()).WillRepeatedly(ReturnRef(setup_state_));
EXPECT_CALL(*this, GetCurrentlyConnectedSsid())
.WillRepeatedly(Return("TestSsid"));
EXPECT_CALL(*this, GetHostedSsid()).WillRepeatedly(Return(""));
EXPECT_CALL(*this, GetTypes())
.WillRepeatedly(Return(std::set<WifiType>{WifiType::kWifi24}));
}
ConnectionState connection_state_{ConnectionState::kOffline};
SetupState setup_state_{SetupState::kNone};
};
class MockCloudDelegate : public CloudDelegate {
public:
MOCK_CONST_METHOD0(GetDeviceId, std::string());
MOCK_CONST_METHOD0(GetModelId, std::string());
MOCK_CONST_METHOD0(GetName, std::string());
MOCK_CONST_METHOD0(GetDescription, std::string());
MOCK_CONST_METHOD0(GetLocation, std::string());
MOCK_METHOD3(UpdateDeviceInfo,
void(const std::string&,
const std::string&,
const std::string&));
MOCK_CONST_METHOD0(GetOemName, std::string());
MOCK_CONST_METHOD0(GetModelName, std::string());
MOCK_CONST_METHOD0(GetAnonymousMaxScope, AuthScope());
MOCK_CONST_METHOD0(GetConnectionState, const ConnectionState&());
MOCK_CONST_METHOD0(GetSetupState, const SetupState&());
MOCK_METHOD2(Setup, bool(const RegistrationData&, ErrorPtr*));
MOCK_CONST_METHOD0(GetCloudId, std::string());
MOCK_CONST_METHOD0(GetOAuthUrl, std::string());
MOCK_CONST_METHOD0(GetServiceUrl, std::string());
MOCK_CONST_METHOD0(GetXmppEndpoint, std::string());
MOCK_CONST_METHOD1(MockGetComponentsForUser,
const base::DictionaryValue&(const UserInfo&));
MOCK_CONST_METHOD2(FindComponent,
const base::DictionaryValue*(const std::string& path,
ErrorPtr* error));
MOCK_CONST_METHOD0(GetTraits, const base::DictionaryValue&());
MOCK_METHOD3(AddCommand,
void(const base::DictionaryValue&,
const UserInfo&,
const CommandDoneCallback&));
MOCK_METHOD3(GetCommand,
void(const std::string&,
const UserInfo&,
const CommandDoneCallback&));
MOCK_METHOD3(CancelCommand,
void(const std::string&,
const UserInfo&,
const CommandDoneCallback&));
MOCK_METHOD2(ListCommands, void(const UserInfo&, const CommandDoneCallback&));
MOCK_METHOD1(AddOnTraitsChangedCallback, void(const base::Closure&));
MOCK_METHOD1(AddOnStateChangedCallback, void(const base::Closure&));
MOCK_METHOD1(AddOnComponentsChangeCallback, void(const base::Closure&));
MockCloudDelegate() {
EXPECT_CALL(*this, GetDeviceId()).WillRepeatedly(Return("TestId"));
EXPECT_CALL(*this, GetOAuthUrl()).WillRepeatedly(Return("https://oauths/"));
EXPECT_CALL(*this, GetServiceUrl())
.WillRepeatedly(Return("https://service/"));
EXPECT_CALL(*this, GetXmppEndpoint()).WillRepeatedly(Return("xmpp:678"));
EXPECT_CALL(*this, GetModelId()).WillRepeatedly(Return("ABMID"));
EXPECT_CALL(*this, GetName()).WillRepeatedly(Return("TestDevice"));
EXPECT_CALL(*this, GetDescription()).WillRepeatedly(Return(""));
EXPECT_CALL(*this, GetLocation()).WillRepeatedly(Return(""));
EXPECT_CALL(*this, UpdateDeviceInfo(_, _, _)).WillRepeatedly(Return());
EXPECT_CALL(*this, GetOemName()).WillRepeatedly(Return("Chromium"));
EXPECT_CALL(*this, GetModelName()).WillRepeatedly(Return("Brillo"));
EXPECT_CALL(*this, GetAnonymousMaxScope())
.WillRepeatedly(Return(AuthScope::kUser));
EXPECT_CALL(*this, GetConnectionState())
.WillRepeatedly(ReturnRef(connection_state_));
EXPECT_CALL(*this, GetSetupState()).WillRepeatedly(ReturnRef(setup_state_));
EXPECT_CALL(*this, GetCloudId()).WillRepeatedly(Return("TestCloudId"));
test_dict_.Set("test", new base::DictionaryValue);
EXPECT_CALL(*this, GetTraits()).WillRepeatedly(ReturnRef(test_dict_));
EXPECT_CALL(*this, MockGetComponentsForUser(_))
.WillRepeatedly(ReturnRef(test_dict_));
EXPECT_CALL(*this, FindComponent(_, _)).Times(0);
EXPECT_CALL(*this, AddOnTraitsChangedCallback(_))
.WillRepeatedly(SaveArg<0>(&on_traits_changed_));
EXPECT_CALL(*this, AddOnStateChangedCallback(_))
.WillRepeatedly(SaveArg<0>(&on_state_changed_));
EXPECT_CALL(*this, AddOnComponentsChangeCallback(_))
.WillRepeatedly(SaveArg<0>(&on_components_changed_));
}
void NotifyOnTraitDefsChanged() { on_traits_changed_.Run(); }
void NotifyOnComponentTreeChanged() { on_components_changed_.Run(); }
void NotifyOnStateChanged() { on_state_changed_.Run(); }
ConnectionState connection_state_{ConnectionState::kOnline};
SetupState setup_state_{SetupState::kNone};
base::DictionaryValue test_dict_;
base::Closure on_traits_changed_;
base::Closure on_state_changed_;
base::Closure on_components_changed_;
private:
std::unique_ptr<base::DictionaryValue> GetComponentsForUser(
const UserInfo& user_info) const override {
return MockGetComponentsForUser(user_info).CreateDeepCopy();
}
};
} // namespace privet
} // namespace weave
#endif // LIBWEAVE_SRC_PRIVET_MOCK_DELEGATES_H_