blob: d6a7c7f2c13674f849fb1283e08b4be2a126f6a2 [file] [log] [blame]
// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <cstring>
#include "base/base_paths.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "base/platform_file.h"
#include "base/time.h"
#include "cobalt/storage/upgrade/upgrade_reader.h"
#include "googleurl/src/gurl.h"
#include "net/cookies/canonical_cookie.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cobalt {
namespace storage {
namespace upgrade {
namespace {
using ::testing::StrictMock;
class MockUpgradeReader : public UpgradeReader {
public:
MOCK_METHOD0(OnNullExpiration, void());
};
void ReadFileToString(const char* pathname, std::string* string_out) {
EXPECT_TRUE(pathname);
EXPECT_TRUE(string_out);
FilePath file_path;
EXPECT_TRUE(PathService::Get(base::DIR_TEST_DATA, &file_path));
file_path = file_path.Append(pathname);
EXPECT_TRUE(file_util::ReadFileToString(file_path, string_out));
const char* data = string_out->c_str();
const int size = static_cast<int>(string_out->length());
EXPECT_GT(size, 0);
EXPECT_LE(size, 10 * 1024 * 1024);
EXPECT_TRUE(UpgradeReader::IsUpgradeData(data, size));
}
void ValidateCookie(const net::CanonicalCookie* cookie, const std::string& url,
const std::string& name, const std::string& value,
const std::string domain, const std::string& path,
const base::Time& creation, const base::Time expiration,
bool http_only) {
EXPECT_TRUE(cookie);
EXPECT_EQ(cookie->Source(),
net::CanonicalCookie::GetCookieSourceFromURL(GURL(url)));
EXPECT_EQ(cookie->Name(), name);
EXPECT_EQ(cookie->Value(), value);
EXPECT_EQ(cookie->Domain(), domain);
EXPECT_EQ(cookie->Path(), path);
EXPECT_EQ((cookie->CreationDate() - creation).InSeconds(), 0);
EXPECT_EQ((cookie->ExpiryDate() - expiration).InSeconds(), 0);
EXPECT_EQ((cookie->LastAccessDate() - base::Time::Now()).InSeconds(), 0);
EXPECT_EQ(cookie->IsSecure(), true);
EXPECT_EQ(cookie->IsHttpOnly(), http_only);
}
void ValidateCookie(const net::CanonicalCookie* cookie, const std::string& url,
const std::string& name, const std::string& value) {
const std::string host = GURL(url).host();
const std::string domain = host.empty() ? "" : host.substr(host.find("."));
const std::string path = "/";
const base::Time creation = base::Time::Now();
const base::Time expiration = base::Time();
const bool http_only = false;
ValidateCookie(cookie, url, name, value, domain, path, creation, expiration,
http_only);
}
void ValidateLocalStorageEntry(
const UpgradeReader::LocalStorageEntry* local_storage_entry,
const std::string& key, const std::string& value) {
EXPECT_TRUE(local_storage_entry);
EXPECT_EQ(local_storage_entry->key, key);
EXPECT_EQ(local_storage_entry->value, value);
}
} // namespace
TEST(StorageUpgradeTest, UpgradeMinimalCookie) {
std::string file_contents;
ReadFileToString("cobalt/storage/upgrade/testdata/minimal_cookie_v1.json",
&file_contents);
StrictMock<MockUpgradeReader> upgrade_reader;
// No expiration
EXPECT_CALL(upgrade_reader, OnNullExpiration());
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// 1 cookie.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 1);
const net::CanonicalCookie* cookie = upgrade_reader.GetCookie(0);
ValidateCookie(cookie, "https://www.example.com/", "cookie_name",
"cookie_value");
EXPECT_FALSE(upgrade_reader.GetCookie(1));
// 0 local storage entries.
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 0);
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(0));
}
TEST(StorageUpgradeTest, UpgradeMinimalLocalStorageEntry) {
std::string file_contents;
ReadFileToString(
"cobalt/storage/upgrade/testdata/minimal_local_storage_entry_v1.json",
&file_contents);
UpgradeReader upgrade_reader;
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// 0 cookies.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 0);
EXPECT_FALSE(upgrade_reader.GetCookie(0));
// 1 local storage entry.
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 1);
const UpgradeReader::LocalStorageEntry* local_storage_entry =
upgrade_reader.GetLocalStorageEntry(0);
ValidateLocalStorageEntry(local_storage_entry, "key-1", "value-1");
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(1));
}
TEST(StorageUpgradeTest, UpgradeFullData) {
std::string file_contents;
ReadFileToString("cobalt/storage/upgrade/testdata/full_data_v1.json",
&file_contents);
UpgradeReader upgrade_reader;
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// 2 cookies.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 2);
const net::CanonicalCookie* cookie = upgrade_reader.GetCookie(0);
base::Time creation = base::Time::FromInternalValue(13119668760000000L);
base::Time expiration = base::Time::FromInternalValue(13120000000000000L);
ValidateCookie(cookie, "https://www.example.com/1", "cookie_name",
"cookie_value", ".example.com", "/1", creation, expiration,
true);
cookie = upgrade_reader.GetCookie(1);
creation = base::Time::FromInternalValue(13109668760000000L);
expiration = base::Time::FromInternalValue(13110000000000000L);
ValidateCookie(cookie, "https://www.somewhere.com/2", "cookie_name_2",
"cookie_value_2", ".somewhere.com", "/2", creation, expiration,
true);
EXPECT_FALSE(upgrade_reader.GetCookie(2));
// 2 local storage entries.
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 2);
const UpgradeReader::LocalStorageEntry* local_storage_entry =
upgrade_reader.GetLocalStorageEntry(0);
ValidateLocalStorageEntry(local_storage_entry, "key-1", "value-1");
local_storage_entry = upgrade_reader.GetLocalStorageEntry(1);
ValidateLocalStorageEntry(local_storage_entry, "key-2", "value-2");
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(2));
}
TEST(StorageUpgradeTest, UpgradeMissingFields) {
std::string file_contents;
ReadFileToString("cobalt/storage/upgrade/testdata/missing_fields_v1.json",
&file_contents);
UpgradeReader upgrade_reader;
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// 1 cookie with missing fields, 2 local storage entries with missing fields,
// 1 valid local storage entry.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 0);
EXPECT_FALSE(upgrade_reader.GetCookie(0));
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 1);
const UpgradeReader::LocalStorageEntry* local_storage_entry =
upgrade_reader.GetLocalStorageEntry(0);
ValidateLocalStorageEntry(local_storage_entry, "key-3", "value-3");
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(1));
}
TEST(StorageUpgradeTest, UpgradeMalformed) {
std::string file_contents;
ReadFileToString("cobalt/storage/upgrade/testdata/malformed_v1.json",
&file_contents);
UpgradeReader upgrade_reader;
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// No cookies or local storage entries available in malformed data.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 0);
EXPECT_FALSE(upgrade_reader.GetCookie(0));
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 0);
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(0));
}
TEST(StorageUpgradeTest, UpgradeExtraFields) {
std::string file_contents;
ReadFileToString("cobalt/storage/upgrade/testdata/extra_fields_v1.json",
&file_contents);
StrictMock<MockUpgradeReader> upgrade_reader;
// No expiration
EXPECT_CALL(upgrade_reader, OnNullExpiration());
upgrade_reader.Parse(file_contents.c_str(),
static_cast<int>(file_contents.length()));
// 1 cookie, extra fields should be ignored.
EXPECT_EQ(upgrade_reader.GetNumCookies(), 1);
const net::CanonicalCookie* cookie = upgrade_reader.GetCookie(0);
ValidateCookie(cookie, "https://www.example.com/", "cookie_name",
"cookie_value");
EXPECT_FALSE(upgrade_reader.GetCookie(1));
// 2 local storage entries, extra fields should be ignored.
EXPECT_EQ(upgrade_reader.GetNumLocalStorageEntries(), 2);
const UpgradeReader::LocalStorageEntry* local_storage_entry =
upgrade_reader.GetLocalStorageEntry(0);
ValidateLocalStorageEntry(local_storage_entry, "key-1", "value-1");
local_storage_entry = upgrade_reader.GetLocalStorageEntry(1);
ValidateLocalStorageEntry(local_storage_entry, "key-2", "value-2");
EXPECT_FALSE(upgrade_reader.GetLocalStorageEntry(2));
}
} // namespace upgrade
} // namespace storage
} // namespace cobalt