blob: bb2743ab6168e28d9ce1442787e00f94770ec687 [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/config.h"
#include <set>
#include <base/bind.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <weave/provider/test/mock_config_store.h>
#include <weave/test/unittest_utils.h>
#include "src/data_encoding.h"
using testing::_;
using testing::Invoke;
using testing::Return;
using testing::WithArgs;
namespace weave {
const char kConfigName[] = "config";
class ConfigTest : public ::testing::Test {
protected:
void SetUp() override {
Reload();
}
void Reload() {
EXPECT_CALL(*this, OnConfigChanged(_)).Times(1);
config_.reset(new Config{&config_store_});
config_->AddOnChangedCallback(
base::Bind(&ConfigTest::OnConfigChanged, base::Unretained(this)));
}
const Config::Settings& GetSettings() const { return config_->GetSettings(); }
const Config::Settings& GetDefaultSettings() const {
return default_.GetSettings();
}
MOCK_METHOD1(OnConfigChanged, void(const Settings&));
provider::test::MockConfigStore config_store_;
std::unique_ptr<Config> config_{new Config{nullptr}};
Config default_{&config_store_};
};
TEST_F(ConfigTest, NoStorage) {
Config config{nullptr};
Config::Transaction change{&config};
change.Commit();
}
TEST_F(ConfigTest, Defaults) {
config_.reset(new Config{nullptr});
EXPECT_EQ("", GetSettings().client_id);
EXPECT_EQ("", GetSettings().client_secret);
EXPECT_EQ("", GetSettings().api_key);
EXPECT_EQ("https://accounts.google.com/o/oauth2/", GetSettings().oauth_url);
EXPECT_EQ("https://www.googleapis.com/weave/v1/", GetSettings().service_url);
EXPECT_EQ("talk.google.com:5223", GetSettings().xmpp_endpoint);
EXPECT_EQ("", GetSettings().oem_name);
EXPECT_EQ("", GetSettings().model_name);
EXPECT_EQ("", GetSettings().model_id);
EXPECT_FALSE(GetSettings().device_id.empty());
EXPECT_EQ("", GetSettings().firmware_version);
EXPECT_TRUE(GetSettings().wifi_auto_setup_enabled);
EXPECT_EQ("", GetSettings().test_privet_ssid);
EXPECT_EQ(std::set<PairingType>{PairingType::kPinCode},
GetSettings().pairing_modes);
EXPECT_EQ("", GetSettings().embedded_code);
EXPECT_EQ("", GetSettings().name);
EXPECT_EQ("", GetSettings().description);
EXPECT_EQ("", GetSettings().location);
EXPECT_EQ(AuthScope::kViewer, GetSettings().local_anonymous_access_role);
EXPECT_TRUE(GetSettings().local_pairing_enabled);
EXPECT_TRUE(GetSettings().local_discovery_enabled);
EXPECT_EQ("", GetSettings().cloud_id);
EXPECT_EQ("", GetSettings().refresh_token);
EXPECT_EQ("", GetSettings().robot_account);
EXPECT_EQ("", GetSettings().last_configured_ssid);
EXPECT_EQ(std::vector<uint8_t>(), GetSettings().secret);
EXPECT_EQ(RootClientTokenOwner::kNone, GetSettings().root_client_token_owner);
}
TEST_F(ConfigTest, LoadStateV0) {
EXPECT_CALL(config_store_, LoadSettings(kConfigName))
.WillOnce(Return(R"({
"device_id": "state_device_id"
})"));
Reload();
EXPECT_EQ("state_device_id", GetSettings().cloud_id);
EXPECT_FALSE(GetSettings().device_id.empty());
EXPECT_NE(GetSettings().cloud_id, GetSettings().device_id);
EXPECT_CALL(config_store_, LoadSettings(kConfigName))
.WillOnce(Return(R"({
"device_id": "state_device_id",
"cloud_id": "state_cloud_id"
})"));
Reload();
EXPECT_EQ("state_cloud_id", GetSettings().cloud_id);
EXPECT_EQ("state_device_id", GetSettings().device_id);
}
TEST_F(ConfigTest, LoadStateUnnamed) {
EXPECT_CALL(config_store_, LoadSettings(kConfigName)).WillOnce(Return(""));
EXPECT_CALL(config_store_, LoadSettings()).Times(1);
Reload();
}
TEST_F(ConfigTest, LoadStateNamed) {
EXPECT_CALL(config_store_, LoadSettings(kConfigName)).WillOnce(Return("{}"));
EXPECT_CALL(config_store_, LoadSettings()).Times(0);
Reload();
}
TEST_F(ConfigTest, LoadState) {
auto state = R"({
"version": 1,
"api_key": "state_api_key",
"client_id": "state_client_id",
"client_secret": "state_client_secret",
"cloud_id": "state_cloud_id",
"description": "state_description",
"device_id": "state_device_id",
"last_configured_ssid": "state_last_configured_ssid",
"local_anonymous_access_role": "user",
"root_client_token_owner": "client",
"local_discovery_enabled": false,
"local_pairing_enabled": false,
"location": "state_location",
"name": "state_name",
"oauth_url": "state_oauth_url",
"refresh_token": "state_refresh_token",
"robot_account": "state_robot_account",
"secret": "c3RhdGVfc2VjcmV0",
"service_url": "state_service_url",
"xmpp_endpoint": "state_xmpp_endpoint"
})";
EXPECT_CALL(config_store_, LoadSettings(kConfigName)).WillOnce(Return(state));
Reload();
EXPECT_EQ("state_client_id", GetSettings().client_id);
EXPECT_EQ("state_client_secret", GetSettings().client_secret);
EXPECT_EQ("state_api_key", GetSettings().api_key);
EXPECT_EQ("state_oauth_url", GetSettings().oauth_url);
EXPECT_EQ("state_service_url", GetSettings().service_url);
EXPECT_EQ("state_xmpp_endpoint", GetSettings().xmpp_endpoint);
EXPECT_EQ(GetDefaultSettings().oem_name, GetSettings().oem_name);
EXPECT_EQ(GetDefaultSettings().model_name, GetSettings().model_name);
EXPECT_EQ(GetDefaultSettings().model_id, GetSettings().model_id);
EXPECT_EQ("state_device_id", GetSettings().device_id);
EXPECT_EQ(GetDefaultSettings().wifi_auto_setup_enabled,
GetSettings().wifi_auto_setup_enabled);
EXPECT_EQ(GetDefaultSettings().test_privet_ssid,
GetSettings().test_privet_ssid);
EXPECT_EQ(GetDefaultSettings().pairing_modes, GetSettings().pairing_modes);
EXPECT_EQ(GetDefaultSettings().embedded_code, GetSettings().embedded_code);
EXPECT_EQ("state_name", GetSettings().name);
EXPECT_EQ("state_description", GetSettings().description);
EXPECT_EQ("state_location", GetSettings().location);
EXPECT_EQ(AuthScope::kUser, GetSettings().local_anonymous_access_role);
EXPECT_FALSE(GetSettings().local_pairing_enabled);
EXPECT_FALSE(GetSettings().local_discovery_enabled);
EXPECT_EQ("state_cloud_id", GetSettings().cloud_id);
EXPECT_EQ("state_refresh_token", GetSettings().refresh_token);
EXPECT_EQ("state_robot_account", GetSettings().robot_account);
EXPECT_EQ("state_last_configured_ssid", GetSettings().last_configured_ssid);
EXPECT_EQ("c3RhdGVfc2VjcmV0", Base64Encode(GetSettings().secret));
EXPECT_EQ(RootClientTokenOwner::kClient,
GetSettings().root_client_token_owner);
}
TEST_F(ConfigTest, Setters) {
Config::Transaction change{config_.get()};
change.set_client_id("set_client_id");
EXPECT_EQ("set_client_id", GetSettings().client_id);
change.set_client_secret("set_client_secret");
EXPECT_EQ("set_client_secret", GetSettings().client_secret);
change.set_api_key("set_api_key");
EXPECT_EQ("set_api_key", GetSettings().api_key);
change.set_oauth_url("set_oauth_url");
EXPECT_EQ("set_oauth_url", GetSettings().oauth_url);
change.set_service_url("set_service_url");
EXPECT_EQ("set_service_url", GetSettings().service_url);
change.set_xmpp_endpoint("set_xmpp_endpoint");
EXPECT_EQ("set_xmpp_endpoint", GetSettings().xmpp_endpoint);
change.set_name("set_name");
EXPECT_EQ("set_name", GetSettings().name);
change.set_description("set_description");
EXPECT_EQ("set_description", GetSettings().description);
change.set_location("set_location");
EXPECT_EQ("set_location", GetSettings().location);
change.set_local_anonymous_access_role(AuthScope::kViewer);
EXPECT_EQ(AuthScope::kViewer, GetSettings().local_anonymous_access_role);
change.set_local_anonymous_access_role(AuthScope::kNone);
EXPECT_EQ(AuthScope::kNone, GetSettings().local_anonymous_access_role);
change.set_local_anonymous_access_role(AuthScope::kUser);
EXPECT_EQ(AuthScope::kUser, GetSettings().local_anonymous_access_role);
change.set_local_discovery_enabled(false);
EXPECT_FALSE(GetSettings().local_discovery_enabled);
change.set_local_pairing_enabled(false);
EXPECT_FALSE(GetSettings().local_pairing_enabled);
change.set_local_discovery_enabled(true);
EXPECT_TRUE(GetSettings().local_discovery_enabled);
change.set_local_pairing_enabled(true);
EXPECT_TRUE(GetSettings().local_pairing_enabled);
change.set_cloud_id("set_cloud_id");
EXPECT_EQ("set_cloud_id", GetSettings().cloud_id);
change.set_device_id("set_device_id");
EXPECT_EQ("set_device_id", GetSettings().device_id);
change.set_refresh_token("set_token");
EXPECT_EQ("set_token", GetSettings().refresh_token);
change.set_robot_account("set_account");
EXPECT_EQ("set_account", GetSettings().robot_account);
change.set_last_configured_ssid("set_last_configured_ssid");
EXPECT_EQ("set_last_configured_ssid", GetSettings().last_configured_ssid);
const std::vector<uint8_t> secret{1, 2, 3, 4, 5};
change.set_secret(secret);
EXPECT_EQ(secret, GetSettings().secret);
change.set_root_client_token_owner(RootClientTokenOwner::kCloud);
EXPECT_EQ(RootClientTokenOwner::kCloud,
GetSettings().root_client_token_owner);
EXPECT_CALL(*this, OnConfigChanged(_)).Times(1);
EXPECT_CALL(config_store_, SaveSettings(kConfigName, _, _))
.WillOnce(WithArgs<1, 2>(
Invoke([](const std::string& json, const DoneCallback& callback) {
auto expected = R"({
'version': 1,
'api_key': 'set_api_key',
'client_id': 'set_client_id',
'client_secret': 'set_client_secret',
'cloud_id': 'set_cloud_id',
'description': 'set_description',
'device_id': 'set_device_id',
'last_configured_ssid': 'set_last_configured_ssid',
'local_anonymous_access_role': 'user',
'root_client_token_owner': 'cloud',
'local_discovery_enabled': true,
'local_pairing_enabled': true,
'location': 'set_location',
'name': 'set_name',
'oauth_url': 'set_oauth_url',
'refresh_token': 'set_token',
'robot_account': 'set_account',
'secret': 'AQIDBAU=',
'service_url': 'set_service_url',
'xmpp_endpoint': 'set_xmpp_endpoint'
})";
EXPECT_JSON_EQ(expected, *test::CreateValue(json));
callback.Run(nullptr);
})));
change.Commit();
}
} // namespace weave