blob: dda8821efaddcdf8f499c4961e5bb3e303808efc [file] [log] [blame]
// Copyright 2018 The Cobalt Authors. 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 <memory>
#include "cobalt/storage/store/memory_store.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/storage/storage_constants.h"
#include "cobalt/storage/store/storage.pb.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
namespace cobalt {
namespace storage {
namespace {
class MemoryStoreTest : public ::testing::Test {
protected:
MemoryStoreTest()
: origin1_(GURL("https://www.example1.com")),
origin2_(GURL("https://www.example2.com")) {
base::Time current_time = base::Time::FromInternalValue(12345);
expiration_time_ = current_time + base::TimeDelta::FromDays(1);
Cookie* cookie = storage_proto_.add_cookies();
cookie->set_name("name");
cookie->set_value("value");
cookie->set_domain("domain");
cookie->set_path("/path/foo");
cookie->set_creation_time_us(current_time.ToInternalValue());
cookie->set_expiration_time_us(expiration_time_.ToInternalValue());
cookie->set_last_access_time_us(current_time.ToInternalValue());
cookie->set_secure(true);
cookie->set_http_only(true);
size_t size = storage_proto_.ByteSize();
storage_data_.resize(size + kStorageHeaderSize);
memcpy(reinterpret_cast<char*>(&storage_data_[0]), kStorageHeader,
kStorageHeaderSize);
storage_proto_.SerializeToArray(
reinterpret_cast<char*>(&storage_data_[kStorageHeaderSize]), size);
memory_store_.Initialize(storage_data_);
cookie_.reset(new net::CanonicalCookie(
"name", "value", "domain", "/path/foo", current_time, expiration_time_,
current_time, true /* secure */, true /* http_only */,
net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
last_access_time_ = current_time + base::TimeDelta::FromDays(50);
updated_cookie_.reset(new net::CanonicalCookie(
"name", "value", "domain", "/path/foo", current_time, expiration_time_,
current_time, true /* secure */, true /* http_only */,
net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
new_cookie_.reset(new net::CanonicalCookie(
"name1", "value2", "domain2", "/path/foo2", current_time,
expiration_time_, current_time, false /* secure */,
false /* http_only */, net::CookieSameSite::DEFAULT_MODE,
net::COOKIE_PRIORITY_DEFAULT));
}
~MemoryStoreTest() {}
loader::Origin origin1_;
loader::Origin origin2_;
Storage storage_proto_;
std::vector<uint8> storage_data_;
std::unique_ptr<net::CanonicalCookie> cookie_;
std::unique_ptr<net::CanonicalCookie> updated_cookie_;
std::unique_ptr<net::CanonicalCookie> new_cookie_;
base::Time last_access_time_;
base::Time expiration_time_;
MemoryStore memory_store_;
};
TEST_F(MemoryStoreTest, Initialize) {
EXPECT_TRUE(memory_store_.Initialize(storage_data_));
}
TEST_F(MemoryStoreTest, Serialize) {
std::vector<uint8> out;
memory_store_.Serialize(&out);
EXPECT_EQ(storage_data_, out);
}
TEST_F(MemoryStoreTest, GetAllCookies) {
std::vector<std::unique_ptr<net::CanonicalCookie>> cookies;
memory_store_.GetAllCookies(&cookies);
EXPECT_EQ(cookies.size(), 1);
EXPECT_TRUE(cookies[0]->IsEquivalent(*cookie_));
}
TEST_F(MemoryStoreTest, AddCookie) {
std::vector<std::unique_ptr<net::CanonicalCookie>> cookies;
memory_store_.GetAllCookies(&cookies);
EXPECT_EQ(cookies.size(), 1);
EXPECT_TRUE(cookies[0]->IsEquivalent(*cookie_));
cookies.clear();
memory_store_.AddCookie(*new_cookie_, expiration_time_.ToInternalValue());
memory_store_.GetAllCookies(&cookies);
EXPECT_EQ(cookies.size(), 2);
EXPECT_TRUE(cookies[0]->IsEquivalent(*cookie_));
EXPECT_TRUE(cookies[1]->IsEquivalent(*new_cookie_));
cookies.clear();
}
TEST_F(MemoryStoreTest, UpdateCookieAccessTime) {
memory_store_.UpdateCookieAccessTime(*cookie_,
last_access_time_.ToInternalValue());
std::vector<std::unique_ptr<net::CanonicalCookie>> cookies;
memory_store_.GetAllCookies(&cookies);
EXPECT_EQ(cookies.size(), 1);
EXPECT_TRUE(cookies[0]->IsEquivalent(*updated_cookie_));
}
TEST_F(MemoryStoreTest, DeleteCookie) {
std::vector<std::unique_ptr<net::CanonicalCookie>> cookies;
memory_store_.GetAllCookies(&cookies);
EXPECT_EQ(cookies.size(), 1);
cookies.clear();
memory_store_.DeleteCookie(*cookie_);
memory_store_.GetAllCookies(&cookies);
EXPECT_TRUE(cookies.empty());
}
TEST_F(MemoryStoreTest, ReadWriteToLocalStorage) {
MemoryStore::LocalStorageMap test_vals;
test_vals["key0"] = "value0";
test_vals["key1"] = "value1";
for (const auto& it : test_vals) {
memory_store_.WriteToLocalStorage(origin1_, it.first, it.second);
}
memory_store_.WriteToLocalStorage(origin2_, "key0", "value0");
MemoryStore::LocalStorageMap read_vals;
memory_store_.ReadAllLocalStorage(origin1_, &read_vals);
EXPECT_EQ(test_vals, read_vals);
}
TEST_F(MemoryStoreTest, DeleteFromLocalStorage) {
MemoryStore::LocalStorageMap test_vals;
test_vals["key0"] = "value0";
test_vals["key1"] = "value1";
for (const auto& it : test_vals) {
memory_store_.WriteToLocalStorage(origin1_, it.first, it.second);
}
memory_store_.DeleteFromLocalStorage(origin1_, "key0");
test_vals.erase("key0");
MemoryStore::LocalStorageMap read_vals;
memory_store_.ReadAllLocalStorage(origin1_, &read_vals);
EXPECT_EQ(test_vals, read_vals);
}
TEST_F(MemoryStoreTest, ClearLocalStorage) {
MemoryStore::LocalStorageMap test_vals;
test_vals["key0"] = "value0";
test_vals["key1"] = "value1";
for (const auto& it : test_vals) {
memory_store_.WriteToLocalStorage(origin1_, it.first, it.second);
}
memory_store_.ClearLocalStorage(origin1_);
MemoryStore::LocalStorageMap read_vals;
memory_store_.ReadAllLocalStorage(origin1_, &read_vals);
EXPECT_TRUE(read_vals.empty());
}
TEST_F(MemoryStoreTest, EmptyStorage) {
MemoryStore empty_store;
std::vector<uint8> in(kStorageHeader, kStorageHeader + kStorageHeaderSize);
empty_store.Initialize(in);
std::vector<uint8> out;
empty_store.Serialize(&out);
EXPECT_EQ(memcmp(kStorageHeader, reinterpret_cast<const char*>(&out[0]),
kStorageHeaderSize),
0);
}
} // namespace
} // namespace storage
} // namespace cobalt