components/sessions/session_backend_unittest.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_util.h"
   6 #include "base/files/scoped_temp_dir.h"
   7 #include "base/stl_util.h"
   8 #include "base/strings/string_util.h"
   9 #include "components/sessions/session_backend.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace sessions {
  13 namespace {
  14
  15 typedef ScopedVector<sessions::SessionCommand> SessionCommands;
  16
  17 struct TestData {
  18   sessions::SessionCommand::id_type command_id;
  19   std::string data;
  20 };
  21
  22 sessions::SessionCommand* CreateCommandFromData(const TestData& data) {
  23   sessions::SessionCommand* command =
  24       new sessions::SessionCommand(
  25           data.command_id,
  26           static_cast<sessions::SessionCommand::size_type>(data.data.size()));
  27   if (!data.data.empty())
  28     memcpy(command->contents(), data.data.c_str(), data.data.size());
  29   return command;
  30 }
  31
  32 }  // namespace
  33
  34 class SessionBackendTest : public testing::Test {
  35  protected:
  36   void SetUp() override {
  37     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  38     path_ = temp_dir_.path().Append(FILE_PATH_LITERAL("SessionTestDirs"));
  39     base::CreateDirectory(path_);
  40   }
  41
  42   void AssertCommandEqualsData(const TestData& data,
  43                                sessions::SessionCommand* command) {
  44     EXPECT_EQ(data.command_id, command->id());
  45     EXPECT_EQ(data.data.size(), command->size());
  46     EXPECT_TRUE(
  47         memcmp(command->contents(), data.data.c_str(), command->size()) == 0);
  48   }
  49
  50   // Path used in testing.
  51   base::FilePath path_;
  52   base::ScopedTempDir temp_dir_;
  53 };
  54
  55 TEST_F(SessionBackendTest, SimpleReadWrite) {
  56   scoped_refptr<SessionBackend> backend(
  57       new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_));
  58   struct TestData data = { 1,  "a" };
  59   SessionCommands commands;
  60   commands.push_back(CreateCommandFromData(data));
  61   backend->AppendCommands(commands.Pass(), false);
  62   ASSERT_TRUE(commands.empty());
  63
  64   // Read it back in.
  65   backend = NULL;
  66   backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE,
  67                                path_);
  68   backend->ReadLastSessionCommandsImpl(&commands);
  69
  70   ASSERT_EQ(1U, commands.size());
  71   AssertCommandEqualsData(data, commands[0]);
  72
  73   commands.clear();
  74
  75   backend = NULL;
  76   backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE,
  77                                path_);
  78   backend->ReadLastSessionCommandsImpl(&commands);
  79
  80   ASSERT_EQ(0U, commands.size());
  81
  82   // Make sure we can delete.
  83   backend->DeleteLastSession();
  84   backend->ReadLastSessionCommandsImpl(&commands);
  85   ASSERT_EQ(0U, commands.size());
  86 }
  87
  88 TEST_F(SessionBackendTest, RandomData) {
  89   struct TestData data[] = {
  90     { 1,  "a" },
  91     { 2,  "ab" },
  92     { 3,  "abc" },
  93     { 4,  "abcd" },
  94     { 5,  "abcde" },
  95     { 6,  "abcdef" },
  96     { 7,  "abcdefg" },
  97     { 8,  "abcdefgh" },
  98     { 9,  "abcdefghi" },
  99     { 10, "abcdefghij" },
 100     { 11, "abcdefghijk" },
 101     { 12, "abcdefghijkl" },
 102     { 13, "abcdefghijklm" },
 103   };
 104
 105   for (size_t i = 0; i < arraysize(data); ++i) {
 106     scoped_refptr<SessionBackend> backend(
 107         new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE,
 108                            path_));
 109     SessionCommands commands;
 110     if (i != 0) {
 111       // Read previous data.
 112       backend->ReadLastSessionCommandsImpl(&commands);
 113       ASSERT_EQ(i, commands.size());
 114       for (std::vector<sessions::SessionCommand*>::iterator j =
 115               commands.begin(); j != commands.end(); ++j) {
 116         AssertCommandEqualsData(data[j - commands.begin()], *j);
 117       }
 118       backend->AppendCommands(commands.Pass(), false);
 119     }
 120     commands.push_back(CreateCommandFromData(data[i]));
 121     backend->AppendCommands(commands.Pass(), false);
 122   }
 123 }
 124
 125 TEST_F(SessionBackendTest, BigData) {
 126   struct TestData data[] = {
 127     { 1,  "a" },
 128     { 2,  "ab" },
 129   };
 130
 131   scoped_refptr<SessionBackend> backend(
 132       new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_));
 133   ScopedVector<sessions::SessionCommand> commands;
 134
 135   commands.push_back(CreateCommandFromData(data[0]));
 136   const sessions::SessionCommand::size_type big_size =
 137       SessionBackend::kFileReadBufferSize + 100;
 138   const sessions::SessionCommand::id_type big_id = 50;
 139   sessions::SessionCommand* big_command =
 140       new sessions::SessionCommand(big_id, big_size);
 141   reinterpret_cast<char*>(big_command->contents())[0] = 'a';
 142   reinterpret_cast<char*>(big_command->contents())[big_size - 1] = 'z';
 143   commands.push_back(big_command);
 144   commands.push_back(CreateCommandFromData(data[1]));
 145   backend->AppendCommands(commands.Pass(), false);
 146
 147   backend = NULL;
 148   backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE,
 149                                path_);
 150
 151   backend->ReadLastSessionCommandsImpl(&commands);
 152   ASSERT_EQ(3U, commands.size());
 153   AssertCommandEqualsData(data[0], commands[0]);
 154   AssertCommandEqualsData(data[1], commands[2]);
 155
 156   EXPECT_EQ(big_id, commands[1]->id());
 157   ASSERT_EQ(big_size, commands[1]->size());
 158   EXPECT_EQ('a', reinterpret_cast<char*>(commands[1]->contents())[0]);
 159   EXPECT_EQ('z',
 160             reinterpret_cast<char*>(commands[1]->contents())[big_size - 1]);
 161   commands.clear();
 162 }
 163
 164 TEST_F(SessionBackendTest, EmptyCommand) {
 165   TestData empty_command;
 166   empty_command.command_id = 1;
 167   scoped_refptr<SessionBackend> backend(
 168       new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_));
 169   SessionCommands empty_commands;
 170   empty_commands.push_back(CreateCommandFromData(empty_command));
 171   backend->AppendCommands(empty_commands.Pass(), true);
 172   backend->MoveCurrentSessionToLastSession();
 173
 174   SessionCommands commands;
 175   backend->ReadLastSessionCommandsImpl(&commands);
 176   ASSERT_EQ(1U, commands.size());
 177   AssertCommandEqualsData(empty_command, commands[0]);
 178   commands.clear();
 179 }
 180
 181 // Writes a command, appends another command with reset to true, then reads
 182 // making sure we only get back the second command.
 183 TEST_F(SessionBackendTest, Truncate) {
 184   scoped_refptr<SessionBackend> backend(
 185       new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_));
 186   struct TestData first_data = { 1,  "a" };
 187   SessionCommands commands;
 188   commands.push_back(CreateCommandFromData(first_data));
 189   backend->AppendCommands(commands.Pass(), false);
 190
 191   // Write another command, this time resetting the file when appending.
 192   struct TestData second_data = { 2,  "b" };
 193   commands.push_back(CreateCommandFromData(second_data));
 194   backend->AppendCommands(commands.Pass(), true);
 195
 196   // Read it back in.
 197   backend = NULL;
 198   backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE,
 199                                path_);
 200   backend->ReadLastSessionCommandsImpl(&commands);
 201
 202   // And make sure we get back the expected data.
 203   ASSERT_EQ(1U, commands.size());
 204   AssertCommandEqualsData(second_data, commands[0]);
 205
 206   commands.clear();
 207 }
 208
 209 }  // namespace sessions