aboutsummaryrefslogtreecommitdiffstats
path: root/tests/unit/unittest/sqlitetable-test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit/unittest/sqlitetable-test.cpp')
-rw-r--r--tests/unit/unittest/sqlitetable-test.cpp202
1 files changed, 190 insertions, 12 deletions
diff --git a/tests/unit/unittest/sqlitetable-test.cpp b/tests/unit/unittest/sqlitetable-test.cpp
index c5ce8e325d..f96b451785 100644
--- a/tests/unit/unittest/sqlitetable-test.cpp
+++ b/tests/unit/unittest/sqlitetable-test.cpp
@@ -32,11 +32,15 @@
namespace {
+using Sqlite::Column;
using Sqlite::ColumnType;
+using Sqlite::ConstraintType;
+using Sqlite::Database;
+using Sqlite::Enforment;
+using Sqlite::ForeignKey;
+using Sqlite::ForeignKeyAction;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
-using Sqlite::Column;
-using Sqlite::Database;
class SqliteTable : public ::testing::Test
{
@@ -110,21 +114,195 @@ TEST_F(SqliteTable, InitializeTableWithIndex)
table.initialize(mockDatabase);
}
+TEST_F(SqliteTable, AddForeignKeyColumnWithTableCalls)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+ table.setName(tableName);
+ table.addForeignKeyColumn("name",
+ foreignTable,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred);
+
+ EXPECT_CALL(mockDatabase,
+ execute(Eq("CREATE TABLE testTable(name INTEGER REFERENCES foreignTable ON UPDATE "
+ "SET NULL ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)")));
-TEST_F(SqliteTable, InitializeTableWithUniqueIndex)
+ table.initialize(mockDatabase);
+}
+
+TEST_F(SqliteTable, AddForeignKeyColumnWithColumnCalls)
{
- InSequence sequence;
- table.setName(tableName.clone());
- auto &column = table.addColumn("name");
- auto &column2 = table.addColumn("value");
- table.addUniqueIndex({column});
- table.addIndex({column2});
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+ auto &foreignColumn = foreignTable.addColumn("foreignColumn", ColumnType::Text, {Sqlite::Unique{}});
+ table.setName(tableName);
+ table.addForeignKeyColumn("name",
+ foreignColumn,
+ ForeignKeyAction::SetDefault,
+ ForeignKeyAction::Restrict,
+ Enforment::Deferred);
- EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE testTable(name NUMERIC, value NUMERIC)")));
- EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_testTable_name ON testTable(name)")));
- EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_testTable_value ON testTable(value)")));
+ EXPECT_CALL(
+ mockDatabase,
+ execute(
+ Eq("CREATE TABLE testTable(name TEXT REFERENCES foreignTable(foreignColumn) ON UPDATE "
+ "SET DEFAULT ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED)")));
table.initialize(mockDatabase);
}
+TEST_F(SqliteTable, AddColumn)
+{
+ table.setName(tableName);
+
+ auto &column = table.addColumn("name", ColumnType::Text, {Sqlite::Unique{}});
+
+ ASSERT_THAT(column,
+ AllOf(Field(&Column::name, Eq("name")),
+ Field(&Column::tableName, Eq(tableName)),
+ Field(&Column::type, ColumnType::Text),
+ Field(&Column::constraints,
+ ElementsAre(VariantWith<Sqlite::Unique>(Eq(Sqlite::Unique{}))))));
+}
+
+TEST_F(SqliteTable, AddForeignKeyColumnWithTable)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+
+ table.setName(tableName);
+
+ auto &column = table.addForeignKeyColumn("name",
+ foreignTable,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred);
+
+ ASSERT_THAT(column,
+ AllOf(Field(&Column::name, Eq("name")),
+ Field(&Column::tableName, Eq(tableName)),
+ Field(&Column::type, ColumnType::Integer),
+ Field(&Column::constraints,
+ ElementsAre(VariantWith<ForeignKey>(
+ AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
+ Field(&ForeignKey::column, IsEmpty()),
+ Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
+ Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+ Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+}
+
+TEST_F(SqliteTable, AddForeignKeyColumnWithColumn)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+ auto &foreignColumn = foreignTable.addColumn("foreignColumn", ColumnType::Text, {Sqlite::Unique{}});
+ table.setName(tableName);
+
+ auto &column = table.addForeignKeyColumn("name",
+ foreignColumn,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred);
+
+ ASSERT_THAT(column,
+ AllOf(Field(&Column::name, Eq("name")),
+ Field(&Column::tableName, Eq(tableName)),
+ Field(&Column::type, ColumnType::Text),
+ Field(&Column::constraints,
+ ElementsAre(VariantWith<ForeignKey>(
+ AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
+ Field(&ForeignKey::column, Eq("foreignColumn")),
+ Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
+ Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+ Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+}
+
+TEST_F(SqliteTable, AddForeignKeyWhichIsNotUniqueThrowsAnExceptions)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+ auto &foreignColumn = foreignTable.addColumn("foreignColumn", ColumnType::Text);
+ table.setName(tableName);
+
+ ASSERT_THROW(table.addForeignKeyColumn("name",
+ foreignColumn,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred),
+ Sqlite::ForeignKeyColumnIsNotUnique);
+}
+
+TEST_F(SqliteTable, AddForeignKeyColumnWithTableAndNotNull)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+
+ table.setName(tableName);
+
+ auto &column = table.addForeignKeyColumn("name",
+ foreignTable,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred,
+ {Sqlite::NotNull{}});
+
+ ASSERT_THAT(column,
+ AllOf(Field(&Column::name, Eq("name")),
+ Field(&Column::tableName, Eq(tableName)),
+ Field(&Column::type, ColumnType::Integer),
+ Field(&Column::constraints,
+ UnorderedElementsAre(
+ VariantWith<ForeignKey>(
+ AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
+ Field(&ForeignKey::column, IsEmpty()),
+ Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
+ Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+ Field(&ForeignKey::enforcement, Enforment::Deferred))),
+ VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
+}
+
+TEST_F(SqliteTable, AddForeignKeyColumnWithColumnAndNotNull)
+{
+ Sqlite::Table foreignTable;
+ foreignTable.setName("foreignTable");
+ auto &foreignColumn = foreignTable.addColumn("foreignColumn", ColumnType::Text, {Sqlite::Unique{}});
+ table.setName(tableName);
+
+ auto &column = table.addForeignKeyColumn("name",
+ foreignColumn,
+ ForeignKeyAction::SetNull,
+ ForeignKeyAction::Cascade,
+ Enforment::Deferred,
+ {Sqlite::NotNull{}});
+
+ ASSERT_THAT(column,
+ AllOf(Field(&Column::name, Eq("name")),
+ Field(&Column::tableName, Eq(tableName)),
+ Field(&Column::type, ColumnType::Text),
+ Field(&Column::constraints,
+ UnorderedElementsAre(
+ VariantWith<ForeignKey>(
+ AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
+ Field(&ForeignKey::column, Eq("foreignColumn")),
+ Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
+ Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+ Field(&ForeignKey::enforcement, Enforment::Deferred))),
+ VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
+}
+
+TEST_F(SqliteTable, AddPrimaryTableContraint)
+{
+ table.setName(tableName.clone());
+ const auto &idColumn = table.addColumn("id");
+ const auto &nameColumn = table.addColumn("name");
+ table.addPrimaryKeyContraint({idColumn, nameColumn});
+
+ EXPECT_CALL(mockDatabase,
+ execute(
+ Eq("CREATE TABLE testTable(id NUMERIC, name NUMERIC, PRIMARY KEY(id, name))")));
+
+ table.initialize(mockDatabase);
}
+} // namespace