blob: ecf479717c4c3115dc2bbbcea2bad21b5b2c241d [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.
#include "src/privet/privet_handler.h"
#include <set>
#include <string>
#include <utility>
#include <base/bind.h>
#include <base/json/json_reader.h>
#include <base/json/json_writer.h>
#include <base/strings/string_util.h>
#include <base/values.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <weave/device.h>
#include <weave/test/unittest_utils.h>
#include "src/privet/constants.h"
#include "src/privet/mock_delegates.h"
#include "src/test/mock_clock.h"
using testing::_;
using testing::DoAll;
using testing::Invoke;
using testing::Return;
using testing::SetArgPointee;
using testing::SaveArg;
using testing::WithArgs;
namespace weave {
namespace privet {
namespace {
void LoadTestJson(const std::string& test_json,
base::DictionaryValue* dictionary) {
int error = 0;
std::string message;
std::unique_ptr<base::Value> value(
base::JSONReader::ReadAndReturnError(test_json, base::JSON_PARSE_RFC,
&error, &message)
.release());
EXPECT_TRUE(value.get()) << "\nError: " << message << "\n" << test_json;
base::DictionaryValue* dictionary_ptr = nullptr;
if (value->GetAsDictionary(&dictionary_ptr))
dictionary->MergeDictionary(dictionary_ptr);
}
struct CodeWithReason {
CodeWithReason(int code_in, const std::string& reason_in)
: code(code_in), reason(reason_in) {}
int code;
std::string reason;
};
std::ostream& operator<<(std::ostream& stream, const CodeWithReason& error) {
return stream << R"({" << error.code << ", " << error.reason << "})";
}
bool IsEqualError(const CodeWithReason& expected,
const base::DictionaryValue& dictionary) {
std::string reason;
int code = 0;
return dictionary.GetInteger("error.http_status", &code) &&
code == expected.code && dictionary.GetString("error.code", &reason) &&
reason == expected.reason;
}
// Some error sections in response JSON objects contained debugging information
// which is of no interest for this test. So, remove the debug info from the
// JSON before running validation logic on it.
std::unique_ptr<base::DictionaryValue> StripDebugErrorDetails(
const std::string& path_to_error_object,
const base::DictionaryValue& value) {
std::unique_ptr<base::DictionaryValue> result{value.DeepCopy()};
base::DictionaryValue* error_dict = nullptr;
EXPECT_TRUE(result->GetDictionary(path_to_error_object, &error_dict));
scoped_ptr<base::Value> dummy;
error_dict->RemovePath("error.debugInfo", &dummy);
error_dict->RemovePath("error.message", &dummy);
return result;
}
} // namespace
class PrivetHandlerTest : public testing::Test {
public:
PrivetHandlerTest() {}
protected:
void SetUp() override {
EXPECT_CALL(clock_, Now())
.WillRepeatedly(Return(base::Time::FromTimeT(1410000001)));
auth_header_ = "Privet anonymous";
handler_.reset(
new PrivetHandler(&cloud_, &device_, &security_, &wifi_, &clock_));
}
const base::DictionaryValue& HandleRequest(
const std::string& api,
const base::DictionaryValue* input) {
output_.Clear();
handler_->HandleRequest(api, auth_header_, input,
base::Bind(&PrivetHandlerTest::HandlerCallback,
base::Unretained(this)));
return output_;
}
const base::DictionaryValue& HandleRequest(const std::string& api,
const std::string& json_input) {
base::DictionaryValue dictionary;
LoadTestJson(json_input, &dictionary);
return HandleRequest(api, &dictionary);
}
void HandleUnknownRequest(const std::string& api) {
output_.Clear();
base::DictionaryValue dictionary;
handler_->HandleRequest(api, auth_header_, &dictionary,
base::Bind(&PrivetHandlerTest::HandlerNoFound));
}
const base::DictionaryValue& GetResponse() const { return output_; }
int GetResponseCount() const { return response_count_; }
void SetNoWifiAndGcd() {
handler_.reset(
new PrivetHandler(&cloud_, &device_, &security_, nullptr, &clock_));
EXPECT_CALL(cloud_, GetCloudId()).WillRepeatedly(Return(""));
EXPECT_CALL(cloud_, GetConnectionState())
.WillRepeatedly(ReturnRef(gcd_disabled_state_));
auto set_error = [](ErrorPtr* error) {
Error::AddTo(error, FROM_HERE, "setupUnavailable", "");
};
EXPECT_CALL(cloud_, Setup(_, _))
.WillRepeatedly(DoAll(WithArgs<1>(Invoke(set_error)), Return(false)));
}
test::MockClock clock_;
testing::StrictMock<MockCloudDelegate> cloud_;
testing::StrictMock<MockDeviceDelegate> device_;
testing::StrictMock<MockSecurityDelegate> security_;
testing::StrictMock<MockWifiDelegate> wifi_;
std::string auth_header_;
private:
void HandlerCallback(int status, const base::DictionaryValue& output) {
output_.Clear();
++response_count_;
output_.MergeDictionary(&output);
if (!output_.HasKey("error")) {
EXPECT_EQ(200, status);
return;
}
EXPECT_NE(200, status);
output_.SetInteger("error.http_status", status);
}
static void HandlerNoFound(int status, const base::DictionaryValue&) {
EXPECT_EQ(404, status);
}
std::unique_ptr<PrivetHandler> handler_;
base::DictionaryValue output_;
int response_count_{0};
ConnectionState gcd_disabled_state_{ConnectionState::kDisabled};
};
TEST_F(PrivetHandlerTest, UnknownApi) {
HandleUnknownRequest("/privet/foo");
}
TEST_F(PrivetHandlerTest, InvalidFormat) {
auth_header_ = "";
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidFormat"),
HandleRequest("/privet/info", nullptr));
}
TEST_F(PrivetHandlerTest, MissingAuth) {
auth_header_ = "";
EXPECT_PRED2(IsEqualError, CodeWithReason(401, "missingAuthorization"),
HandleRequest("/privet/info", "{}"));
}
TEST_F(PrivetHandlerTest, InvalidAuth) {
auth_header_ = "foo";
EXPECT_PRED2(IsEqualError, CodeWithReason(401, "invalidAuthorization"),
HandleRequest("/privet/info", "{}"));
}
TEST_F(PrivetHandlerTest, ExpiredAuth) {
auth_header_ = "Privet 123";
EXPECT_CALL(security_, ParseAccessToken(_, _, _))
.WillRepeatedly(WithArgs<2>(Invoke([](ErrorPtr* error) {
return Error::AddTo(error, FROM_HERE, "authorizationExpired", "");
})));
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "authorizationExpired"),
HandleRequest("/privet/info", "{}"));
}
TEST_F(PrivetHandlerTest, InvalidAuthScope) {
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthorizationScope"),
HandleRequest("/privet/v3/setup/start", "{}"));
}
TEST_F(PrivetHandlerTest, InfoMinimal) {
SetNoWifiAndGcd();
EXPECT_CALL(security_, GetPairingTypes())
.WillRepeatedly(Return(std::set<PairingType>{}));
EXPECT_CALL(security_, GetCryptoTypes())
.WillRepeatedly(Return(std::set<CryptoType>{}));
EXPECT_CALL(security_, GetAuthTypes())
.WillRepeatedly(Return(std::set<AuthType>{}));
const char kExpected[] = R"({
"version": "3.0",
"id": "TestId",
"name": "TestDevice",
"services": [ "developmentBoard" ],
"modelManifestId": "ABMID",
"basicModelManifest": {
"uiDeviceKind": "developmentBoard",
"oemName": "Chromium",
"modelName": "Brillo"
},
"endpoints": {
"httpPort": 0,
"httpUpdatesPort": 0,
"httpsPort": 0,
"httpsUpdatesPort": 0
},
"authentication": {
"anonymousMaxScope": "user",
"mode": [
],
"pairing": [
],
"crypto": [
]
},
"gcd": {
"id": "",
"oauth_url": "https://oauths/",
"service_url": "https://service/",
"status": "disabled",
"xmpp_endpoint": "xmpp:678"
},
"time": 1410000001000.0,
"sessionId": "SessionId"
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/info", "{}"));
}
TEST_F(PrivetHandlerTest, Info) {
EXPECT_CALL(cloud_, GetDescription())
.WillRepeatedly(Return("TestDescription"));
EXPECT_CALL(cloud_, GetLocation()).WillRepeatedly(Return("TestLocation"));
EXPECT_CALL(device_, GetHttpEnpoint())
.WillRepeatedly(Return(std::make_pair(80, 10080)));
EXPECT_CALL(device_, GetHttpsEnpoint())
.WillRepeatedly(Return(std::make_pair(443, 10443)));
EXPECT_CALL(wifi_, GetHostedSsid())
.WillRepeatedly(Return("Test_device.BBABCLAprv"));
const char kExpected[] = R"({
"version": "3.0",
"id": "TestId",
"name": "TestDevice",
"description": "TestDescription",
"location": "TestLocation",
"services": [ "developmentBoard" ],
"modelManifestId": "ABMID",
"basicModelManifest": {
"uiDeviceKind": "developmentBoard",
"oemName": "Chromium",
"modelName": "Brillo"
},
"endpoints": {
"httpPort": 80,
"httpUpdatesPort": 10080,
"httpsPort": 443,
"httpsUpdatesPort": 10443
},
"authentication": {
"anonymousMaxScope": "none",
"mode": [
"anonymous",
"pairing",
"local"
],
"pairing": [
"pinCode",
"embeddedCode"
],
"crypto": [
"p224_spake2"
]
},
"wifi": {
"capabilities": [
"2.4GHz"
],
"ssid": "TestSsid",
"hostedSsid": "Test_device.BBABCLAprv",
"status": "offline"
},
"gcd": {
"id": "TestCloudId",
"oauth_url": "https://oauths/",
"service_url": "https://service/",
"status": "online",
"xmpp_endpoint": "xmpp:678"
},
"time": 1410000001000.0,
"sessionId": "SessionId"
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/info", "{}"));
}
TEST_F(PrivetHandlerTest, PairingStartInvalidParams) {
EXPECT_PRED2(
IsEqualError, CodeWithReason(400, "invalidParams"),
HandleRequest("/privet/v3/pairing/start",
R"({"pairing":"embeddedCode","crypto":"crypto"})"));
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
HandleRequest("/privet/v3/pairing/start",
R"({"pairing":"code","crypto":"p224_spake2"})"));
}
TEST_F(PrivetHandlerTest, PairingStart) {
EXPECT_JSON_EQ(
R"({"deviceCommitment": "testCommitment", "sessionId": "testSession"})",
HandleRequest("/privet/v3/pairing/start",
R"({"pairing": "embeddedCode", "crypto": "p224_spake2"})"));
}
TEST_F(PrivetHandlerTest, PairingConfirm) {
EXPECT_JSON_EQ(
R"({"certFingerprint":"testFingerprint","certSignature":"testSignature"})",
HandleRequest(
"/privet/v3/pairing/confirm",
R"({"sessionId":"testSession","clientCommitment":"testCommitment"})"));
}
TEST_F(PrivetHandlerTest, PairingCancel) {
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/pairing/cancel",
R"({"sessionId": "testSession"})"));
}
TEST_F(PrivetHandlerTest, AuthErrorNoType) {
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidAuthMode"),
HandleRequest("/privet/v3/auth", "{}"));
}
TEST_F(PrivetHandlerTest, AuthErrorInvalidType) {
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidAuthMode"),
HandleRequest("/privet/v3/auth", R"({"mode":"unknown"})"));
}
TEST_F(PrivetHandlerTest, AuthErrorNoScope) {
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
HandleRequest("/privet/v3/auth", R"({"mode":"anonymous"})"));
}
TEST_F(PrivetHandlerTest, AuthErrorInvalidScope) {
EXPECT_PRED2(
IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
HandleRequest("/privet/v3/auth",
R"({"mode":"anonymous","requestedScope":"unknown"})"));
}
TEST_F(PrivetHandlerTest, AuthErrorAccessDenied) {
EXPECT_PRED2(
IsEqualError, CodeWithReason(403, "accessDenied"),
HandleRequest("/privet/v3/auth",
R"({"mode":"anonymous","requestedScope":"owner"})"));
}
TEST_F(PrivetHandlerTest, AuthErrorInvalidAuthCode) {
auto set_error = [](ErrorPtr* error) {
return Error::AddTo(error, FROM_HERE, "invalidAuthCode", "");
};
EXPECT_CALL(security_, CreateAccessToken(_, "testToken", _, _, _, _, _))
.WillRepeatedly(WithArgs<6>(Invoke(set_error)));
const char kInput[] = R"({
"mode": "pairing",
"requestedScope": "user",
"authCode": "testToken"
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthCode"),
HandleRequest("/privet/v3/auth", kInput));
}
TEST_F(PrivetHandlerTest, AuthAnonymous) {
const char kExpected[] = R"({
"accessToken": "GuestAccessToken",
"expiresIn": 15,
"scope": "viewer",
"tokenType": "Privet"
})";
EXPECT_JSON_EQ(
kExpected,
HandleRequest("/privet/v3/auth",
R"({"mode":"anonymous","requestedScope":"auto"})"));
}
TEST_F(PrivetHandlerTest, AuthPairing) {
EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<3>("OwnerAccessToken"),
SetArgPointee<4>(AuthScope::kOwner),
SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
Return(true)));
const char kInput[] = R"({
"mode": "pairing",
"requestedScope": "owner",
"authCode": "testToken"
})";
const char kExpected[] = R"({
"accessToken": "OwnerAccessToken",
"expiresIn": 15,
"scope": "owner",
"tokenType": "Privet"
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}
TEST_F(PrivetHandlerTest, AuthLocalAuto) {
EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<3>("UserAccessToken"),
SetArgPointee<4>(AuthScope::kUser),
SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
Return(true)));
const char kInput[] = R"({
"mode": "local",
"requestedScope": "auto",
"authCode": "localAuthToken"
})";
const char kExpected[] = R"({
"accessToken": "UserAccessToken",
"expiresIn": 15,
"scope": "user",
"tokenType": "Privet"
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}
TEST_F(PrivetHandlerTest, AuthLocal) {
EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<3>("ManagerAccessToken"),
SetArgPointee<4>(AuthScope::kManager),
SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
Return(true)));
const char kInput[] = R"({
"mode": "local",
"requestedScope": "manager",
"authCode": "localAuthToken"
})";
const char kExpected[] = R"({
"accessToken": "ManagerAccessToken",
"expiresIn": 15,
"scope": "manager",
"tokenType": "Privet"
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}
TEST_F(PrivetHandlerTest, AuthLocalHighScope) {
EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
.WillRepeatedly(DoAll(SetArgPointee<3>("UserAccessToken"),
SetArgPointee<4>(AuthScope::kUser),
SetArgPointee<5>(base::TimeDelta::FromSeconds(1)),
Return(true)));
const char kInput[] = R"({
"mode": "local",
"requestedScope": "manager",
"authCode": "localAuthToken"
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "accessDenied"),
HandleRequest("/privet/v3/auth", kInput));
}
class PrivetHandlerTestWithAuth : public PrivetHandlerTest {
public:
void SetUp() override {
PrivetHandlerTest::SetUp();
auth_header_ = "Privet 123";
EXPECT_CALL(security_, ParseAccessToken(_, _, _))
.WillRepeatedly(DoAll(
SetArgPointee<1>(UserInfo{AuthScope::kOwner, TestUserId{"1"}}),
Return(true)));
}
};
class PrivetHandlerSetupTest : public PrivetHandlerTestWithAuth {};
TEST_F(PrivetHandlerSetupTest, StatusEmpty) {
SetNoWifiAndGcd();
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/setup/status", "{}"));
}
TEST_F(PrivetHandlerSetupTest, StatusWifi) {
wifi_.setup_state_ = SetupState{SetupState::kSuccess};
const char kExpected[] = R"({
"wifi": {
"ssid": "TestSsid",
"status": "success"
}
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/status", "{}"));
}
TEST_F(PrivetHandlerSetupTest, StatusWifiError) {
ErrorPtr error;
Error::AddTo(&error, FROM_HERE, "invalidPassphrase", "");
wifi_.setup_state_ = SetupState{std::move(error)};
const char kExpected[] = R"({
"wifi": {
"status": "error",
"error": {
"code": "invalidPassphrase"
}
}
})";
EXPECT_JSON_EQ(kExpected,
*StripDebugErrorDetails(
"wifi", HandleRequest("/privet/v3/setup/status", "{}")));
}
TEST_F(PrivetHandlerSetupTest, StatusGcd) {
cloud_.setup_state_ = SetupState{SetupState::kSuccess};
const char kExpected[] = R"({
"gcd": {
"id": "TestCloudId",
"oauth_url": "https://oauths/",
"service_url": "https://service/",
"status": "success",
"xmpp_endpoint": "xmpp:678"
}
})";
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/status", "{}"));
}
TEST_F(PrivetHandlerSetupTest, StatusGcdError) {
ErrorPtr error;
Error::AddTo(&error, FROM_HERE, "invalidTicket", "");
cloud_.setup_state_ = SetupState{std::move(error)};
const char kExpected[] = R"({
"gcd": {
"status": "error",
"error": {
"code": "invalidTicket"
}
}
})";
EXPECT_JSON_EQ(kExpected,
*StripDebugErrorDetails(
"gcd", HandleRequest("/privet/v3/setup/status", "{}")));
}
TEST_F(PrivetHandlerSetupTest, SetupNameDescriptionLocation) {
EXPECT_CALL(cloud_,
UpdateDeviceInfo("testName", "testDescription", "testLocation"))
.Times(1);
const char kInput[] = R"({
"name": "testName",
"description": "testDescription",
"location": "testLocation"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerSetupTest, InvalidParams) {
const char kInputWifi[] = R"({
"wifi": {
"ssid": ""
}
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
HandleRequest("/privet/v3/setup/start", kInputWifi));
const char kInputRegistration[] = R"({
"gcd": {
"ticketId": ""
}
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
HandleRequest("/privet/v3/setup/start", kInputRegistration));
}
TEST_F(PrivetHandlerSetupTest, WifiSetupUnavailable) {
SetNoWifiAndGcd();
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "setupUnavailable"),
HandleRequest("/privet/v3/setup/start", R"({"wifi": {}})"));
}
TEST_F(PrivetHandlerSetupTest, WifiSetup) {
const char kInput[] = R"({
"wifi": {
"ssid": "testSsid",
"passphrase": "testPass"
}
})";
auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
return Error::AddTo(error, FROM_HERE, "deviceBusy", "");
};
EXPECT_CALL(wifi_, ConfigureCredentials(_, _, _)).WillOnce(Invoke(set_error));
EXPECT_PRED2(IsEqualError, CodeWithReason(503, "deviceBusy"),
HandleRequest("/privet/v3/setup/start", kInput));
const char kExpected[] = R"({
"wifi": {
"status": "inProgress"
}
})";
wifi_.setup_state_ = SetupState{SetupState::kInProgress};
EXPECT_CALL(wifi_, ConfigureCredentials("testSsid", "testPass", _))
.WillOnce(Return(true));
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerSetupTest, GcdSetupUnavailable) {
SetNoWifiAndGcd();
const char kInput[] = R"({
"gcd": {
"ticketId": "testTicket",
"user": "testUser"
}
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "setupUnavailable"),
HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerSetupTest, GcdSetup) {
const char kInput[] = R"({
"gcd": {
"ticketId": "testTicket",
"user": "testUser"
}
})";
auto set_error = [](ErrorPtr* error) {
return Error::AddTo(error, FROM_HERE, "deviceBusy", "");
};
EXPECT_CALL(cloud_, Setup(_, _)).WillOnce(WithArgs<1>(Invoke(set_error)));
EXPECT_PRED2(IsEqualError, CodeWithReason(503, "deviceBusy"),
HandleRequest("/privet/v3/setup/start", kInput));
const char kExpected[] = R"({
"gcd": {
"status": "inProgress"
}
})";
cloud_.setup_state_ = SetupState{SetupState::kInProgress};
EXPECT_CALL(cloud_, Setup(RegistrationData{"testTicket"}, _))
.WillOnce(Return(true));
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerSetupTest, GcdSetupWithEndpoints) {
const char kInput[] = R"({
"gcd": {
"api_key": "test_api_key",
"client_id": "test_client_id",
"client_secret": "test_client_secret",
"oauth_url": "https://oauths/",
"service_url": "https://service/",
"xmpp_endpoint": "xmpp:678",
"ticketId": "testTicket",
"user": "testUser"
}
})";
const char kExpected[] = R"({
"gcd": {
"status": "inProgress"
}
})";
cloud_.setup_state_ = SetupState{SetupState::kInProgress};
RegistrationData expected_reg_data;
expected_reg_data.ticket_id = "testTicket";
expected_reg_data.oauth_url = "https://oauths/";
expected_reg_data.client_id = "test_client_id";
expected_reg_data.client_secret = "test_client_secret";
expected_reg_data.api_key = "test_api_key";
expected_reg_data.service_url = "https://service/";
expected_reg_data.xmpp_endpoint = "xmpp:678";
EXPECT_CALL(cloud_, Setup(expected_reg_data, _)).WillOnce(Return(true));
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerSetupTest, GcdSetupAsMaster) {
EXPECT_CALL(security_, ParseAccessToken(_, _, _))
.WillRepeatedly(DoAll(
SetArgPointee<1>(UserInfo{AuthScope::kManager, TestUserId{"1"}}),
Return(true)));
const char kInput[] = R"({
"gcd": {
"ticketId": "testTicket",
"user": "testUser"
}
})";
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthorizationScope"),
HandleRequest("/privet/v3/setup/start", kInput));
}
TEST_F(PrivetHandlerTestWithAuth, ClaimAccessControl) {
EXPECT_JSON_EQ(R"({"clientToken": "RootClientAuthToken"})",
HandleRequest("/privet/v3/accessControl/claim", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, ConfirmAccessControl) {
EXPECT_JSON_EQ("{}",
HandleRequest("/privet/v3/accessControl/confirm",
R"({"clientToken": "DerivedClientAuthToken"})"));
}
TEST_F(PrivetHandlerTestWithAuth, Traits) {
EXPECT_JSON_EQ(R"({"traits": {"test": {}}, "fingerprint": "1"})",
HandleRequest("/privet/v3/traits", "{}"));
cloud_.NotifyOnTraitDefsChanged();
EXPECT_JSON_EQ(R"({"traits": {"test": {}}, "fingerprint": "2"})",
HandleRequest("/privet/v3/traits", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, Components) {
EXPECT_JSON_EQ(R"({"components": {"test": {}}, "fingerprint": "1"})",
HandleRequest("/privet/v3/components", "{}"));
cloud_.NotifyOnComponentTreeChanged();
EXPECT_JSON_EQ(R"({"components": {"test": {}}, "fingerprint": "2"})",
HandleRequest("/privet/v3/components", "{}"));
// State change will also change the components fingerprint.
cloud_.NotifyOnStateChanged();
EXPECT_JSON_EQ(R"({"components": {"test": {}}, "fingerprint": "3"})",
HandleRequest("/privet/v3/components", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, ComponentsWithFiltersAndPaths) {
const char kComponents[] = R"({
"comp1": {
"traits": ["a", "b"],
"state": {
"a" : {
"prop": 1
}
},
"components": {
"comp2": {
"traits": ["c"],
"components": {
"comp4": {
"traits": ["d"]
}
}
},
"comp3": {
"traits": ["e"]
}
}
}
})";
base::DictionaryValue components;
LoadTestJson(kComponents, &components);
EXPECT_CALL(cloud_, FindComponent(_, _)).WillRepeatedly(Return(nullptr));
EXPECT_CALL(cloud_, GetComponents()).WillRepeatedly(ReturnRef(components));
const char kExpected1[] = R"({
"components": {
"comp1": {
"state": {
"a" : {
"prop": 1
}
}
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected1, HandleRequest("/privet/v3/components",
R"({"filter":["state"]})"));
const char kExpected2[] = R"({
"components": {
"comp1": {
"traits": ["a", "b"]
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected2, HandleRequest("/privet/v3/components",
R"({"filter":["traits"]})"));
const char kExpected3[] = R"({
"components": {
"comp1": {
"components": {
"comp2": {
"components": {
"comp4": {}
}
},
"comp3": {}
}
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected3, HandleRequest("/privet/v3/components",
R"({"filter":["components"]})"));
const char kExpected4[] = R"({
"components": {
"comp1": {
"traits": ["a", "b"],
"state": {
"a" : {
"prop": 1
}
},
"components": {
"comp2": {
"traits": ["c"],
"components": {
"comp4": {
"traits": ["d"]
}
}
},
"comp3": {
"traits": ["e"]
}
}
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(
kExpected4,
HandleRequest("/privet/v3/components",
R"({"filter":["traits", "components", "state"]})"));
const base::DictionaryValue* comp2 = nullptr;
ASSERT_TRUE(components.GetDictionary("comp1.components.comp2", &comp2));
EXPECT_CALL(cloud_, FindComponent("comp1.comp2", _)).WillOnce(Return(comp2));
const char kExpected5[] = R"({
"components": {
"comp2": {
"traits": ["c"],
"components": {
"comp4": {
"traits": ["d"]
}
}
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(
kExpected5,
HandleRequest(
"/privet/v3/components",
R"({"path":"comp1.comp2", "filter":["traits", "components"]})"));
auto error_handler = [](ErrorPtr* error) -> const base::DictionaryValue* {
return Error::AddTo(error, FROM_HERE, "componentNotFound", "");
};
EXPECT_CALL(cloud_, FindComponent("comp7", _))
.WillOnce(WithArgs<1>(Invoke(error_handler)));
EXPECT_PRED2(
IsEqualError, CodeWithReason(500, "componentNotFound"),
HandleRequest("/privet/v3/components",
R"({"path":"comp7", "filter":["traits", "components"]})"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsExecute) {
const char kInput[] = R"({"name": "test"})";
base::DictionaryValue command;
LoadTestJson(kInput, &command);
LoadTestJson(R"({"id":"5"})", &command);
EXPECT_CALL(cloud_, AddCommand(_, _, _))
.WillOnce(WithArgs<2>(Invoke(
[&command](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(command, nullptr);
})));
EXPECT_JSON_EQ(R"({"name":"test", "id":"5"})",
HandleRequest("/privet/v3/commands/execute", kInput));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsStatus) {
const char kInput[] = R"({"id": "5"})";
base::DictionaryValue command;
LoadTestJson(kInput, &command);
LoadTestJson(R"({"name":"test"})", &command);
EXPECT_CALL(cloud_, GetCommand(_, _, _))
.WillOnce(WithArgs<2>(Invoke(
[&command](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(command, nullptr);
})));
EXPECT_JSON_EQ(R"({"name":"test", "id":"5"})",
HandleRequest("/privet/v3/commands/status", kInput));
ErrorPtr error;
Error::AddTo(&error, FROM_HERE, "notFound", "");
EXPECT_CALL(cloud_, GetCommand(_, _, _))
.WillOnce(WithArgs<2>(
Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run({}, std::move(error));
})));
EXPECT_PRED2(IsEqualError, CodeWithReason(404, "notFound"),
HandleRequest("/privet/v3/commands/status", R"({"id": "15"})"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsCancel) {
const char kExpected[] = R"({"id": "5", "name":"test", "state":"cancelled"})";
base::DictionaryValue command;
LoadTestJson(kExpected, &command);
EXPECT_CALL(cloud_, CancelCommand(_, _, _))
.WillOnce(WithArgs<2>(Invoke(
[&command](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(command, nullptr);
})));
EXPECT_JSON_EQ(kExpected,
HandleRequest("/privet/v3/commands/cancel", R"({"id": "8"})"));
ErrorPtr error;
Error::AddTo(&error, FROM_HERE, "notFound", "");
EXPECT_CALL(cloud_, CancelCommand(_, _, _))
.WillOnce(WithArgs<2>(
Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run({}, std::move(error));
})));
EXPECT_PRED2(IsEqualError, CodeWithReason(404, "notFound"),
HandleRequest("/privet/v3/commands/cancel", R"({"id": "11"})"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsList) {
const char kExpected[] = R"({
"commands" : [
{"id":"5", "state":"cancelled"},
{"id":"15", "state":"inProgress"}
]})";
base::DictionaryValue commands;
LoadTestJson(kExpected, &commands);
EXPECT_CALL(cloud_, ListCommands(_, _))
.WillOnce(WithArgs<1>(Invoke(
[&commands](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(commands, nullptr);
})));
EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/commands/list", "{}"));
}
class PrivetHandlerCheckForUpdatesTest : public PrivetHandlerTestWithAuth {};
TEST_F(PrivetHandlerCheckForUpdatesTest, NoInput) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
cloud_.NotifyOnTraitDefsChanged();
cloud_.NotifyOnComponentTreeChanged();
cloud_.NotifyOnStateChanged();
const char kInput[] = "{}";
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "2",
"traitsFingerprint": "2",
"componentsFingerprint": "3"
})";
EXPECT_JSON_EQ(kExpected,
HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(1, GetResponseCount());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, AlreadyChanged) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
cloud_.NotifyOnTraitDefsChanged();
cloud_.NotifyOnComponentTreeChanged();
cloud_.NotifyOnStateChanged();
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "2",
"traitsFingerprint": "2",
"componentsFingerprint": "3"
})";
EXPECT_JSON_EQ(kExpected,
HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(1, GetResponseCount());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollCommands) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnTraitDefsChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "1",
"traitsFingerprint": "2",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollTraits) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnTraitDefsChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "1",
"traitsFingerprint": "2",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollState) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnStateChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "2",
"traitsFingerprint": "1",
"componentsFingerprint": "2"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollComponents) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnComponentTreeChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "2"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollIgnoreTraits) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"stateFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnTraitDefsChanged();
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnComponentTreeChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "1",
"traitsFingerprint": "2",
"componentsFingerprint": "2"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollIgnoreState) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"traitsFingerprint": "1"
})";
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnStateChanged();
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnComponentTreeChanged();
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnTraitDefsChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "2",
"traitsFingerprint": "2",
"componentsFingerprint": "3"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, InstantTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1",
"waitTimeout": 0
})";
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected,
HandleRequest("/privet/v3/checkForUpdates", kInput));
}
TEST_F(PrivetHandlerCheckForUpdatesTest, UserTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1",
"waitTimeout": 3
})";
base::Closure callback;
EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(3)))
.WillOnce(SaveArg<1>(&callback));
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
callback.Run();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, ServerTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::FromMinutes(1)));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
base::Closure callback;
EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(50)))
.WillOnce(SaveArg<1>(&callback));
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
callback.Run();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, VeryShortServerTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::FromSeconds(5)));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kInput, HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(1, GetResponseCount());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, ServerAndUserTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::FromMinutes(1)));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1",
"waitTimeout": 10
})";
base::Closure callback;
EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(10)))
.WillOnce(SaveArg<1>(&callback));
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
callback.Run();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
}
TEST_F(PrivetHandlerCheckForUpdatesTest, ChangeBeforeTimeout) {
EXPECT_CALL(device_, GetHttpRequestTimeout())
.WillOnce(Return(base::TimeDelta::Max()));
const char kInput[] = R"({
"commandsFingerprint": "1",
"stateFingerprint": "1",
"traitsFingerprint": "1",
"componentsFingerprint": "1",
"waitTimeout": 10
})";
base::Closure callback;
EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(10)))
.WillOnce(SaveArg<1>(&callback));
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
EXPECT_EQ(0, GetResponseCount());
cloud_.NotifyOnTraitDefsChanged();
EXPECT_EQ(1, GetResponseCount());
const char kExpected[] = R"({
"commandsFingerprint": "2",
"stateFingerprint": "1",
"traitsFingerprint": "2",
"componentsFingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected, GetResponse());
callback.Run();
EXPECT_EQ(1, GetResponseCount());
}
} // namespace privet
} // namespace weave