blob: 20f5aa08cd098823d9c16fccc28fb9511c5960f9 [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/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) {
std::string json = test_json;
base::ReplaceChars(json, "'", "\"", &json);
int error = 0;
std::string message;
std::unique_ptr<base::Value> value(
base::JSONReader::ReadAndReturnError(json, base::JSON_PARSE_RFC, &error,
&message)
.release());
EXPECT_TRUE(value.get()) << "\nError: " << message << "\n" << 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 << "{" << 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 = [](const std::string&, const std::string&,
ErrorPtr* error) {
Error::AddTo(error, FROM_HERE, "setupUnavailable", "");
};
EXPECT_CALL(cloud_, Setup(_, _, _))
.WillRepeatedly(DoAll(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': '',
'status': 'disabled'
},
'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',
'status': 'online'
},
'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",
"{'pairing':'embeddedCode','crypto':'crypto'}"));
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
HandleRequest("/privet/v3/pairing/start",
"{'pairing':'code','crypto':'p224_spake2'}"));
}
TEST_F(PrivetHandlerTest, PairingStart) {
EXPECT_JSON_EQ(
"{'deviceCommitment': 'testCommitment', 'sessionId': 'testSession'}",
HandleRequest("/privet/v3/pairing/start",
"{'pairing': 'embeddedCode', 'crypto': 'p224_spake2'}"));
}
TEST_F(PrivetHandlerTest, PairingConfirm) {
EXPECT_JSON_EQ(
"{'certFingerprint':'testFingerprint','certSignature':'testSignature'}",
HandleRequest(
"/privet/v3/pairing/confirm",
"{'sessionId':'testSession','clientCommitment':'testCommitment'}"));
}
TEST_F(PrivetHandlerTest, PairingCancel) {
EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/pairing/cancel",
"{'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", "{'mode':'unknown'}"));
}
TEST_F(PrivetHandlerTest, AuthErrorNoScope) {
EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
HandleRequest("/privet/v3/auth", "{'mode':'anonymous'}"));
}
TEST_F(PrivetHandlerTest, AuthErrorInvalidScope) {
EXPECT_PRED2(
IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
HandleRequest("/privet/v3/auth",
"{'mode':'anonymous','requestedScope':'unknown'}"));
}
TEST_F(PrivetHandlerTest, AuthErrorAccessDenied) {
EXPECT_PRED2(IsEqualError, CodeWithReason(403, "accessDenied"),
HandleRequest("/privet/v3/auth",
"{'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",
"{'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',
'status': 'success'
}
})";
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", "{'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 = [](const std::string&, const std::string&, ErrorPtr* error) {
return Error::AddTo(error, FROM_HERE, "deviceBusy", "");
};
EXPECT_CALL(cloud_, Setup(_, _, _)).WillOnce(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("testTicket", "testUser", _))
.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("{'clientToken': 'RootClientAuthToken'}",
HandleRequest("/privet/v3/accessControl/claim", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, ConfirmAccessControl) {
EXPECT_JSON_EQ("{}",
HandleRequest("/privet/v3/accessControl/confirm",
"{'clientToken': 'DerivedClientAuthToken'}"));
}
TEST_F(PrivetHandlerTestWithAuth, State) {
EXPECT_JSON_EQ("{'state': {'test': {}}, 'fingerprint': '1'}",
HandleRequest("/privet/v3/state", "{}"));
cloud_.NotifyOnStateChanged();
EXPECT_JSON_EQ("{'state': {'test': {}}, 'fingerprint': '2'}",
HandleRequest("/privet/v3/state", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsDefs) {
EXPECT_JSON_EQ("{'commands': {'test':{}}, 'fingerprint': '1'}",
HandleRequest("/privet/v3/commandDefs", "{}"));
cloud_.NotifyOnTraitDefsChanged();
EXPECT_JSON_EQ("{'commands': {'test':{}}, 'fingerprint': '2'}",
HandleRequest("/privet/v3/commandDefs", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, Traits) {
EXPECT_JSON_EQ("{'traits': {'test': {}}, 'fingerprint': '1'}",
HandleRequest("/privet/v3/traits", "{}"));
cloud_.NotifyOnTraitDefsChanged();
EXPECT_JSON_EQ("{'traits': {'test': {}}, 'fingerprint': '2'}",
HandleRequest("/privet/v3/traits", "{}"));
}
TEST_F(PrivetHandlerTestWithAuth, Components) {
EXPECT_JSON_EQ("{'components': {'test': {}}, 'fingerprint': '1'}",
HandleRequest("/privet/v3/components", "{}"));
cloud_.NotifyOnComponentTreeChanged();
EXPECT_JSON_EQ("{'components': {'test': {}}, 'fingerprint': '2'}",
HandleRequest("/privet/v3/components", "{}"));
// State change will also change the components fingerprint.
cloud_.NotifyOnStateChanged();
EXPECT_JSON_EQ("{'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",
"{'filter':['state']}"));
const char kExpected2[] = R"({
"components": {
"comp1": {
"traits": ["a", "b"]
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected2, HandleRequest("/privet/v3/components",
"{'filter':['traits']}"));
const char kExpected3[] = R"({
"components": {
"comp1": {
"components": {
"comp2": {
"components": {
"comp4": {}
}
},
"comp3": {}
}
}
},
"fingerprint": "1"
})";
EXPECT_JSON_EQ(kExpected3, HandleRequest("/privet/v3/components",
"{'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",
"{'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",
"{'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",
"{'path':'comp7', 'filter':['traits', 'components']}"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsExecute) {
const char kInput[] = "{'name': 'test'}";
base::DictionaryValue command;
LoadTestJson(kInput, &command);
LoadTestJson("{'id':'5'}", &command);
EXPECT_CALL(cloud_, AddCommand(_, _, _))
.WillOnce(WithArgs<2>(Invoke(
[&command](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(command, nullptr);
})));
EXPECT_JSON_EQ("{'name':'test', 'id':'5'}",
HandleRequest("/privet/v3/commands/execute", kInput));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsStatus) {
const char kInput[] = "{'id': '5'}";
base::DictionaryValue command;
LoadTestJson(kInput, &command);
LoadTestJson("{'name':'test'}", &command);
EXPECT_CALL(cloud_, GetCommand(_, _, _))
.WillOnce(WithArgs<2>(Invoke(
[&command](const CloudDelegate::CommandDoneCallback& callback) {
callback.Run(command, nullptr);
})));
EXPECT_JSON_EQ("{'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", "{'id': '15'}"));
}
TEST_F(PrivetHandlerTestWithAuth, CommandsCancel) {
const char kExpected[] = "{'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", "{'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", "{'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