sql/meta_table_unittest.cc

   1 // Copyright 2013 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 "sql/meta_table.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "sql/connection.h"
  10 #include "sql/statement.h"
  11 #include "sql/test/sql_test_base.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace {
  15
  16 using SQLMetaTableTest = sql::SQLTestBase;
  17
  18 TEST_F(SQLMetaTableTest, DoesTableExist) {
  19   EXPECT_FALSE(sql::MetaTable::DoesTableExist(&db()));
  20
  21   {
  22     sql::MetaTable meta_table;
  23     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
  24   }
  25
  26   EXPECT_TRUE(sql::MetaTable::DoesTableExist(&db()));
  27 }
  28
  29 TEST_F(SQLMetaTableTest, RazeIfDeprecated) {
  30   const int kDeprecatedVersion = 1;
  31   const int kVersion = 2;
  32
  33   // Setup a current database.
  34   {
  35     sql::MetaTable meta_table;
  36     EXPECT_TRUE(meta_table.Init(&db(), kVersion, kVersion));
  37     EXPECT_TRUE(db().Execute("CREATE TABLE t(c)"));
  38     EXPECT_TRUE(db().DoesTableExist("t"));
  39   }
  40
  41   // Table should should still exist if the database version is new enough.
  42   sql::MetaTable::RazeIfDeprecated(&db(), kDeprecatedVersion);
  43   EXPECT_TRUE(db().DoesTableExist("t"));
  44
  45   // TODO(shess): It may make sense to Raze() if meta isn't present or
  46   // version isn't present.  See meta_table.h TODO on RazeIfDeprecated().
  47
  48   // Table should still exist if the version is not available.
  49   EXPECT_TRUE(db().Execute("DELETE FROM meta WHERE key = 'version'"));
  50   {
  51     sql::MetaTable meta_table;
  52     EXPECT_TRUE(meta_table.Init(&db(), kVersion, kVersion));
  53     EXPECT_EQ(0, meta_table.GetVersionNumber());
  54   }
  55   sql::MetaTable::RazeIfDeprecated(&db(), kDeprecatedVersion);
  56   EXPECT_TRUE(db().DoesTableExist("t"));
  57
  58   // Table should still exist if meta table is missing.
  59   EXPECT_TRUE(db().Execute("DROP TABLE meta"));
  60   sql::MetaTable::RazeIfDeprecated(&db(), kDeprecatedVersion);
  61   EXPECT_TRUE(db().DoesTableExist("t"));
  62
  63   // Setup meta with deprecated version.
  64   {
  65     sql::MetaTable meta_table;
  66     EXPECT_TRUE(meta_table.Init(&db(), kDeprecatedVersion, kDeprecatedVersion));
  67   }
  68
  69   // Deprecation check should remove the table.
  70   EXPECT_TRUE(db().DoesTableExist("t"));
  71   sql::MetaTable::RazeIfDeprecated(&db(), kDeprecatedVersion);
  72   EXPECT_FALSE(sql::MetaTable::DoesTableExist(&db()));
  73   EXPECT_FALSE(db().DoesTableExist("t"));
  74 }
  75
  76 TEST_F(SQLMetaTableTest, VersionNumber) {
  77   // Compatibility versions one less than the main versions to make
  78   // sure the values aren't being crossed with each other.
  79   const int kVersionFirst = 2;
  80   const int kCompatVersionFirst = kVersionFirst - 1;
  81   const int kVersionSecond = 4;
  82   const int kCompatVersionSecond = kVersionSecond - 1;
  83   const int kVersionThird = 6;
  84   const int kCompatVersionThird = kVersionThird - 1;
  85
  86   // First Init() sets the version info as expected.
  87   {
  88     sql::MetaTable meta_table;
  89     EXPECT_TRUE(meta_table.Init(&db(), kVersionFirst, kCompatVersionFirst));
  90     EXPECT_EQ(kVersionFirst, meta_table.GetVersionNumber());
  91     EXPECT_EQ(kCompatVersionFirst, meta_table.GetCompatibleVersionNumber());
  92   }
  93
  94   // Second Init() does not change the version info.
  95   {
  96     sql::MetaTable meta_table;
  97     EXPECT_TRUE(meta_table.Init(&db(), kVersionSecond, kCompatVersionSecond));
  98     EXPECT_EQ(kVersionFirst, meta_table.GetVersionNumber());
  99     EXPECT_EQ(kCompatVersionFirst, meta_table.GetCompatibleVersionNumber());
 100
 101     meta_table.SetVersionNumber(kVersionSecond);
 102     meta_table.SetCompatibleVersionNumber(kCompatVersionSecond);
 103   }
 104
 105   // Version info from Set*() calls is seen.
 106   {
 107     sql::MetaTable meta_table;
 108     EXPECT_TRUE(meta_table.Init(&db(), kVersionThird, kCompatVersionThird));
 109     EXPECT_EQ(kVersionSecond, meta_table.GetVersionNumber());
 110     EXPECT_EQ(kCompatVersionSecond, meta_table.GetCompatibleVersionNumber());
 111   }
 112 }
 113
 114 TEST_F(SQLMetaTableTest, StringValue) {
 115   const char kKey[] = "String Key";
 116   const std::string kFirstValue("First Value");
 117   const std::string kSecondValue("Second Value");
 118
 119   // Initially, the value isn't there until set.
 120   {
 121     sql::MetaTable meta_table;
 122     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 123
 124     std::string value;
 125     EXPECT_FALSE(meta_table.GetValue(kKey, &value));
 126
 127     EXPECT_TRUE(meta_table.SetValue(kKey, kFirstValue));
 128     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 129     EXPECT_EQ(kFirstValue, value);
 130   }
 131
 132   // Value is persistent across different instances.
 133   {
 134     sql::MetaTable meta_table;
 135     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 136
 137     std::string value;
 138     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 139     EXPECT_EQ(kFirstValue, value);
 140
 141     EXPECT_TRUE(meta_table.SetValue(kKey, kSecondValue));
 142   }
 143
 144   // Existing value was successfully changed.
 145   {
 146     sql::MetaTable meta_table;
 147     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 148
 149     std::string value;
 150     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 151     EXPECT_EQ(kSecondValue, value);
 152   }
 153 }
 154
 155 TEST_F(SQLMetaTableTest, IntValue) {
 156   const char kKey[] = "Int Key";
 157   const int kFirstValue = 17;
 158   const int kSecondValue = 23;
 159
 160   // Initially, the value isn't there until set.
 161   {
 162     sql::MetaTable meta_table;
 163     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 164
 165     int value;
 166     EXPECT_FALSE(meta_table.GetValue(kKey, &value));
 167
 168     EXPECT_TRUE(meta_table.SetValue(kKey, kFirstValue));
 169     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 170     EXPECT_EQ(kFirstValue, value);
 171   }
 172
 173   // Value is persistent across different instances.
 174   {
 175     sql::MetaTable meta_table;
 176     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 177
 178     int value;
 179     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 180     EXPECT_EQ(kFirstValue, value);
 181
 182     EXPECT_TRUE(meta_table.SetValue(kKey, kSecondValue));
 183   }
 184
 185   // Existing value was successfully changed.
 186   {
 187     sql::MetaTable meta_table;
 188     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 189
 190     int value;
 191     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 192     EXPECT_EQ(kSecondValue, value);
 193   }
 194 }
 195
 196 TEST_F(SQLMetaTableTest, Int64Value) {
 197   const char kKey[] = "Int Key";
 198   const int64_t kFirstValue = 5000000017LL;
 199   const int64_t kSecondValue = 5000000023LL;
 200
 201   // Initially, the value isn't there until set.
 202   {
 203     sql::MetaTable meta_table;
 204     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 205
 206     int64_t value;
 207     EXPECT_FALSE(meta_table.GetValue(kKey, &value));
 208
 209     EXPECT_TRUE(meta_table.SetValue(kKey, kFirstValue));
 210     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 211     EXPECT_EQ(kFirstValue, value);
 212   }
 213
 214   // Value is persistent across different instances.
 215   {
 216     sql::MetaTable meta_table;
 217     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 218
 219     int64_t value;
 220     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 221     EXPECT_EQ(kFirstValue, value);
 222
 223     EXPECT_TRUE(meta_table.SetValue(kKey, kSecondValue));
 224   }
 225
 226   // Existing value was successfully changed.
 227   {
 228     sql::MetaTable meta_table;
 229     EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 230
 231     int64_t value;
 232     EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 233     EXPECT_EQ(kSecondValue, value);
 234   }
 235 }
 236
 237 TEST_F(SQLMetaTableTest, DeleteKey) {
 238   const char kKey[] = "String Key";
 239   const std::string kValue("String Value");
 240
 241   sql::MetaTable meta_table;
 242   EXPECT_TRUE(meta_table.Init(&db(), 1, 1));
 243
 244   // Value isn't present.
 245   std::string value;
 246   EXPECT_FALSE(meta_table.GetValue(kKey, &value));
 247
 248   // Now value is present.
 249   EXPECT_TRUE(meta_table.SetValue(kKey, kValue));
 250   EXPECT_TRUE(meta_table.GetValue(kKey, &value));
 251   EXPECT_EQ(kValue, value);
 252
 253   // After delete value isn't present.
 254   EXPECT_TRUE(meta_table.DeleteKey(kKey));
 255   EXPECT_FALSE(meta_table.GetValue(kKey, &value));
 256 }
 257
 258 }  // namespace