src/privet/mock_delegates.h

// 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::Return;
using testing::ReturnRef;
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_METHOD0(GetComponents, const base::DictionaryValue&());
  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&));

  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, GetComponents()).WillRepeatedly(ReturnRef(test_dict_));
    EXPECT_CALL(*this, FindComponent(_, _)).Times(0);
  }

  ConnectionState connection_state_{ConnectionState::kOnline};
  SetupState setup_state_{SetupState::kNone};
  base::DictionaryValue test_dict_;
};

}  // namespace privet
}  // namespace weave

#endif  // LIBWEAVE_SRC_PRIVET_MOCK_DELEGATES_H_