diff options
Diffstat (limited to 'tests/unit')
-rw-r--r-- | tests/unit/unittest/createtablesqlstatementbuilder-test.cpp | 635 | ||||
-rw-r--r-- | tests/unit/unittest/sqlitecolumn-test.cpp | 128 | ||||
-rw-r--r-- | tests/unit/unittest/sqlitetable-test.cpp | 302 | ||||
-rw-r--r-- | tests/unit/unittest/sqlstatementbuilder-test.cpp | 10 |
4 files changed, 1004 insertions, 71 deletions
diff --git a/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp b/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp index 0e92b06897..130a2e3042 100644 --- a/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp +++ b/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp @@ -39,13 +39,15 @@ using Sqlite::ForeignKeyAction; using Sqlite::JournalMode; using Sqlite::OpenMode; using Sqlite::PrimaryKey; -using Sqlite::SqliteColumns; using Sqlite::SqlStatementBuilderException; +using Sqlite::StrictColumnType; using Sqlite::Unique; class CreateTableSqlStatementBuilder : public ::testing::Test { protected: + using Columns = ::Sqlite::Columns; + using Builder = Sqlite::CreateTableSqlStatementBuilder<ColumnType>; void bindValues() { builder.clear(); @@ -55,9 +57,9 @@ protected: builder.addColumn("number", ColumnType::Numeric); } - static SqliteColumns createColumns() + static Columns createColumns() { - SqliteColumns columns; + Columns columns; columns.emplace_back("", "id", ColumnType::Integer, Sqlite::Constraints{PrimaryKey{}}); columns.emplace_back("", "name", ColumnType::Text); columns.emplace_back("", "number", ColumnType::Numeric); @@ -66,7 +68,7 @@ protected: } protected: - Sqlite::CreateTableSqlStatementBuilder builder; + Builder builder; }; TEST_F(CreateTableSqlStatementBuilder, IsNotValidAfterCreation) @@ -125,8 +127,7 @@ TEST_F(CreateTableSqlStatementBuilder, ChangeTable) builder.setTableName("test2"); ASSERT_THAT(builder.sqlStatement(), - "CREATE TABLE test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)" - ); + "CREATE TABLE test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"); } TEST_F(CreateTableSqlStatementBuilder, IsInvalidAfterClearColumsOnly) @@ -163,7 +164,6 @@ TEST_F(CreateTableSqlStatementBuilder, SetWitoutRowId) TEST_F(CreateTableSqlStatementBuilder, SetColumnDefinitions) { - builder.clear(); builder.setTableName("test"); builder.setColumns(createColumns()); @@ -174,7 +174,6 @@ TEST_F(CreateTableSqlStatementBuilder, SetColumnDefinitions) TEST_F(CreateTableSqlStatementBuilder, UniqueContraint) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {Unique{}}); @@ -185,7 +184,6 @@ TEST_F(CreateTableSqlStatementBuilder, UniqueContraint) TEST_F(CreateTableSqlStatementBuilder, IfNotExitsModifier) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {}); @@ -197,7 +195,6 @@ TEST_F(CreateTableSqlStatementBuilder, IfNotExitsModifier) TEST_F(CreateTableSqlStatementBuilder, TemporaryTable) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {}); @@ -209,7 +206,6 @@ TEST_F(CreateTableSqlStatementBuilder, TemporaryTable) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyWithoutColumn) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {ForeignKey{"otherTable", ""}}); @@ -219,7 +215,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyWithoutColumn) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyWithColumn) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); @@ -230,7 +225,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyWithColumn) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateNoAction) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); @@ -241,7 +235,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateNoAction) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateRestrict) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -255,7 +248,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateRestrict) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateSetNull) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -269,7 +261,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateSetNull) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateSetDefault) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -283,7 +274,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateSetDefault) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateCascade) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -297,7 +287,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyUpdateCascade) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteNoAction) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); @@ -308,7 +297,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteNoAction) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteRestrict) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -322,7 +310,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteRestrict) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteSetNull) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -336,7 +323,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteSetNull) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteSetDefault) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -350,7 +336,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteSetDefault) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteCascade) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -364,7 +349,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteCascade) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteAndUpdateAction) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -381,7 +365,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeleteAndUpdateAction) TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeferred) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -399,7 +382,6 @@ TEST_F(CreateTableSqlStatementBuilder, ForeignKeyDeferred) TEST_F(CreateTableSqlStatementBuilder, NotNullConstraint) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {Sqlite::NotNull{}}); @@ -409,7 +391,6 @@ TEST_F(CreateTableSqlStatementBuilder, NotNullConstraint) TEST_F(CreateTableSqlStatementBuilder, NotNullAndUniqueConstraint) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {Sqlite::Unique{}, Sqlite::NotNull{}}); @@ -419,7 +400,6 @@ TEST_F(CreateTableSqlStatementBuilder, NotNullAndUniqueConstraint) TEST_F(CreateTableSqlStatementBuilder, Check) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Text, {Sqlite::Check{"id != ''"}}); @@ -429,7 +409,6 @@ TEST_F(CreateTableSqlStatementBuilder, Check) TEST_F(CreateTableSqlStatementBuilder, DefaultValueInt) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {Sqlite::DefaultValue{1LL}}); @@ -439,7 +418,6 @@ TEST_F(CreateTableSqlStatementBuilder, DefaultValueInt) TEST_F(CreateTableSqlStatementBuilder, DefaultValueFloat) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Real, {Sqlite::DefaultValue{1.1}}); @@ -449,7 +427,6 @@ TEST_F(CreateTableSqlStatementBuilder, DefaultValueFloat) TEST_F(CreateTableSqlStatementBuilder, DefaultValueString) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Text, {Sqlite::DefaultValue{"foo"}}); @@ -459,7 +436,6 @@ TEST_F(CreateTableSqlStatementBuilder, DefaultValueString) TEST_F(CreateTableSqlStatementBuilder, DefaultExpression) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -472,7 +448,6 @@ TEST_F(CreateTableSqlStatementBuilder, DefaultExpression) TEST_F(CreateTableSqlStatementBuilder, Collation) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Text, {Sqlite::Collate{"unicode"}}); @@ -482,7 +457,6 @@ TEST_F(CreateTableSqlStatementBuilder, Collation) TEST_F(CreateTableSqlStatementBuilder, GeneratedAlwaysStored) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -497,7 +471,6 @@ TEST_F(CreateTableSqlStatementBuilder, GeneratedAlwaysStored) TEST_F(CreateTableSqlStatementBuilder, GeneratedAlwaysVirtual) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", @@ -512,7 +485,6 @@ TEST_F(CreateTableSqlStatementBuilder, GeneratedAlwaysVirtual) TEST_F(CreateTableSqlStatementBuilder, PrimaryKeyAutoincrement) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer, {Sqlite::PrimaryKey{Sqlite::AutoIncrement::Yes}}); @@ -522,7 +494,6 @@ TEST_F(CreateTableSqlStatementBuilder, PrimaryKeyAutoincrement) TEST_F(CreateTableSqlStatementBuilder, BlobType) { - builder.clear(); builder.setTableName("test"); builder.addColumn("data", ColumnType::Blob); @@ -532,7 +503,6 @@ TEST_F(CreateTableSqlStatementBuilder, BlobType) TEST_F(CreateTableSqlStatementBuilder, TablePrimaryKeyConstaint) { - builder.clear(); builder.setTableName("test"); builder.addColumn("id", ColumnType::Integer); builder.addColumn("text", ColumnType::Text); @@ -543,4 +513,595 @@ TEST_F(CreateTableSqlStatementBuilder, TablePrimaryKeyConstaint) ASSERT_THAT(statement, "CREATE TABLE test(id INTEGER, text TEXT, PRIMARY KEY(id, text))"); } +TEST_F(CreateTableSqlStatementBuilder, NoneColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::None); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id)"); +} + +TEST_F(CreateTableSqlStatementBuilder, NumericColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::Numeric); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id NUMERIC)"); +} + +TEST_F(CreateTableSqlStatementBuilder, IntegerColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::Integer); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id INTEGER)"); +} + +TEST_F(CreateTableSqlStatementBuilder, RealColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::Real); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id REAL)"); +} + +TEST_F(CreateTableSqlStatementBuilder, TextColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::Text); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id TEXT)"); +} + +TEST_F(CreateTableSqlStatementBuilder, BlobColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", ColumnType::Blob); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id BLOB)"); +} + +class CreateStrictTableSqlStatementBuilder : public ::testing::Test +{ +protected: + using Columns = ::Sqlite::StrictColumns; + + void bindValues() + { + builder.clear(); + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Integer, {PrimaryKey{}}); + builder.addColumn("name", StrictColumnType::Text); + builder.addColumn("number", StrictColumnType::Any); + } + + static Columns createColumns() + { + Columns columns; + columns.emplace_back("", "id", StrictColumnType::Integer, Sqlite::Constraints{PrimaryKey{}}); + columns.emplace_back("", "name", StrictColumnType::Text); + columns.emplace_back("", "number", StrictColumnType::Any); + + return columns; + } + +protected: + Sqlite::CreateTableSqlStatementBuilder<StrictColumnType> builder; +}; + +TEST_F(CreateStrictTableSqlStatementBuilder, IsNotValidAfterCreation) +{ + ASSERT_FALSE(builder.isValid()); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, IsValidAfterBinding) +{ + bindValues(); + + ASSERT_TRUE(builder.isValid()); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, InvalidAfterClear) +{ + bindValues(); + + builder.clear(); + + ASSERT_TRUE(!builder.isValid()); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, NoSqlStatementAfterClear) +{ + bindValues(); + builder.sqlStatement(); + + builder.clear(); + + ASSERT_THROW(builder.sqlStatement(), SqlStatementBuilderException); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, SqlStatement) +{ + bindValues(); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number ANY) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, AddColumnToExistingColumns) +{ + bindValues(); + + builder.addColumn("number2", StrictColumnType::Real); + + ASSERT_THAT( + builder.sqlStatement(), + "CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number ANY, number2 REAL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ChangeTable) +{ + bindValues(); + + builder.setTableName("test2"); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test2(id INTEGER PRIMARY KEY, name TEXT, number ANY) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, IsInvalidAfterClearColumsOnly) +{ + bindValues(); + builder.sqlStatement(); + + builder.clearColumns(); + + ASSERT_THROW(builder.sqlStatement(), SqlStatementBuilderException); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ClearColumnsAndAddColumnNewColumns) +{ + bindValues(); + builder.clearColumns(); + + builder.addColumn("name3", StrictColumnType::Text); + builder.addColumn("number3", StrictColumnType::Real); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(name3 TEXT, number3 REAL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, SetWitoutRowId) +{ + bindValues(); + + builder.setUseWithoutRowId(true); + + ASSERT_THAT( + builder.sqlStatement(), + "CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number ANY) WITHOUT ROWID STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, SetColumnDefinitions) +{ + builder.setTableName("test"); + + builder.setColumns(createColumns()); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number ANY) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, UniqueContraint) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {Unique{}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id INTEGER UNIQUE) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, IfNotExitsModifier) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Integer, {}); + + builder.setUseIfNotExists(true); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE IF NOT EXISTS test(id INTEGER) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, TemporaryTable) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Integer, {}); + + builder.setUseTemporaryTable(true); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TEMPORARY TABLE test(id INTEGER) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyWithoutColumn) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {ForeignKey{"otherTable", ""}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id INTEGER REFERENCES otherTable) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyWithColumn) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn)) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyUpdateNoAction) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn)) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyUpdateRestrict) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", ForeignKeyAction::Restrict}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE " + "RESTRICT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyUpdateSetNull) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", ForeignKeyAction::SetNull}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE SET " + "NULL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyUpdateSetDefault) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", ForeignKeyAction::SetDefault}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE SET " + "DEFAULT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyUpdateCascade) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", ForeignKeyAction::Cascade}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE " + "CASCADE) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteNoAction) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {ForeignKey{"otherTable", "otherColumn"}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn)) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteRestrict) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", {}, ForeignKeyAction::Restrict}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON DELETE " + "RESTRICT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteSetNull) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", {}, ForeignKeyAction::SetNull}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON DELETE SET " + "NULL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteSetDefault) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", {}, ForeignKeyAction::SetDefault}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON DELETE SET " + "DEFAULT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteCascade) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", "otherColumn", {}, ForeignKeyAction::Cascade}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON DELETE " + "CASCADE) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeleteAndUpdateAction) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", + "otherColumn", + ForeignKeyAction::SetDefault, + ForeignKeyAction::Cascade}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE SET " + "DEFAULT ON DELETE CASCADE) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, ForeignKeyDeferred) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {ForeignKey{"otherTable", + "otherColumn", + ForeignKeyAction::SetDefault, + ForeignKeyAction::Cascade, + Enforment::Deferred}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER REFERENCES otherTable(otherColumn) ON UPDATE SET " + "DEFAULT ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, NotNullConstraint) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {Sqlite::NotNull{}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id INTEGER NOT NULL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, NotNullAndUniqueConstraint) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {Sqlite::Unique{}, Sqlite::NotNull{}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id INTEGER UNIQUE NOT NULL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, Check) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Text, {Sqlite::Check{"id != ''"}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id TEXT CHECK (id != '')) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, DefaultValueInt) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Integer, {Sqlite::DefaultValue{1LL}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id INTEGER DEFAULT 1) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, DefaultValueFloat) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Real, {Sqlite::DefaultValue{1.1}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id REAL DEFAULT 1.100000) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, DefaultValueString) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Text, {Sqlite::DefaultValue{"foo"}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id TEXT DEFAULT 'foo') STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, DefaultExpression) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {Sqlite::DefaultExpression{"SELECT name FROM foo WHERE id=?"}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER DEFAULT (SELECT name FROM foo WHERE id=?)) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, Collation) +{ + builder.setTableName("test"); + + builder.addColumn("id", StrictColumnType::Text, {Sqlite::Collate{"unicode"}}); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(id TEXT COLLATE unicode) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, GeneratedAlwaysStored) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Text, + {Sqlite::GeneratedAlways{"SELECT name FROM foo WHERE id=?", + Sqlite::GeneratedAlwaysStorage::Stored}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id TEXT GENERATED ALWAYS AS (SELECT name FROM foo WHERE id=?) " + "STORED) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, GeneratedAlwaysVirtual) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Text, + {Sqlite::GeneratedAlways{"SELECT name FROM foo WHERE id=?", + Sqlite::GeneratedAlwaysStorage::Virtual}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id TEXT GENERATED ALWAYS AS (SELECT name FROM foo WHERE id=?) " + "VIRTUAL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, PrimaryKeyAutoincrement) +{ + builder.setTableName("test"); + + builder.addColumn("id", + StrictColumnType::Integer, + {Sqlite::PrimaryKey{Sqlite::AutoIncrement::Yes}}); + + ASSERT_THAT(builder.sqlStatement(), + "CREATE TABLE test(id INTEGER PRIMARY KEY AUTOINCREMENT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, BlobType) +{ + builder.setTableName("test"); + + builder.addColumn("data", StrictColumnType::Blob); + + ASSERT_THAT(builder.sqlStatement(), "CREATE TABLE test(data BLOB) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, TablePrimaryKeyConstaint) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Integer); + builder.addColumn("text", StrictColumnType::Text); + + builder.addConstraint(Sqlite::TablePrimaryKey{{"id, text"}}); + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id INTEGER, text TEXT, PRIMARY KEY(id, text)) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, AnyColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Any); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id ANY) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, IntColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Int); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id INT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, IntegerColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Integer); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id INTEGER) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, RealColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Real); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id REAL) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, TextColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Text); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id TEXT) STRICT"); +} + +TEST_F(CreateStrictTableSqlStatementBuilder, BlobColumnTypeStringConversion) +{ + builder.setTableName("test"); + builder.addColumn("id", StrictColumnType::Blob); + + auto statement = builder.sqlStatement(); + + ASSERT_THAT(statement, "CREATE TABLE test(id BLOB) STRICT"); +} + } // namespace diff --git a/tests/unit/unittest/sqlitecolumn-test.cpp b/tests/unit/unittest/sqlitecolumn-test.cpp index 9753457c94..865726d54f 100644 --- a/tests/unit/unittest/sqlitecolumn-test.cpp +++ b/tests/unit/unittest/sqlitecolumn-test.cpp @@ -31,18 +31,19 @@ namespace { using Sqlite::ColumnType; using Sqlite::ConstraintType; -using Sqlite::JournalMode; -using Sqlite::OpenMode; -using Column = Sqlite::Column; using Sqlite::Enforment; using Sqlite::ForeignKey; using Sqlite::ForeignKeyAction; -using Sqlite::SqliteColumns; +using Sqlite::JournalMode; +using Sqlite::OpenMode; +using Sqlite::StrictColumnType; class SqliteColumn : public ::testing::Test { protected: - Sqlite::Column column; + using Column = Sqlite::Column; + + Column column; }; TEST_F(SqliteColumn, DefaultConstruct) @@ -50,7 +51,7 @@ TEST_F(SqliteColumn, DefaultConstruct) ASSERT_THAT(column, AllOf(Field(&Column::name, IsEmpty()), Field(&Column::tableName, IsEmpty()), - Field(&Column::type, ColumnType::Numeric), + Field(&Column::type, ColumnType::None), Field(&Column::constraints, IsEmpty()))); } @@ -66,20 +67,20 @@ TEST_F(SqliteColumn, Clear) ASSERT_THAT(column, AllOf(Field(&Column::name, IsEmpty()), Field(&Column::tableName, IsEmpty()), - Field(&Column::type, ColumnType::Numeric), + Field(&Column::type, ColumnType::None), Field(&Column::constraints, IsEmpty()))); } TEST_F(SqliteColumn, Constructor) { - column = Sqlite::Column{"table", - "column", - ColumnType::Text, - {ForeignKey{"referencedTable", - "referencedColumn", - ForeignKeyAction::SetNull, - ForeignKeyAction::Cascade, - Enforment::Deferred}}}; + column = Column{"table", + "column", + ColumnType::Text, + {ForeignKey{"referencedTable", + "referencedColumn", + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred}}}; ASSERT_THAT(column, AllOf(Field(&Column::name, Eq("column")), @@ -96,14 +97,14 @@ TEST_F(SqliteColumn, Constructor) TEST_F(SqliteColumn, FlatConstructor) { - column = Sqlite::Column{"table", - "column", - ColumnType::Text, - {ForeignKey{"referencedTable", - "referencedColumn", - ForeignKeyAction::SetNull, - ForeignKeyAction::Cascade, - Enforment::Deferred}}}; + column = Column{"table", + "column", + ColumnType::Text, + {ForeignKey{"referencedTable", + "referencedColumn", + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred}}}; ASSERT_THAT(column, AllOf(Field(&Column::name, Eq("column")), @@ -118,4 +119,85 @@ TEST_F(SqliteColumn, FlatConstructor) Field(&ForeignKey::enforcement, Enforment::Deferred))))))); } +class SqliteStrictColumn : public ::testing::Test +{ +protected: + using Column = Sqlite::StrictColumn; + + Column column; +}; + +TEST_F(SqliteStrictColumn, DefaultConstruct) +{ + ASSERT_THAT(column, + AllOf(Field(&Column::name, IsEmpty()), + Field(&Column::tableName, IsEmpty()), + Field(&Column::type, StrictColumnType::Any), + Field(&Column::constraints, IsEmpty()))); +} + +TEST_F(SqliteStrictColumn, Clear) +{ + column.name = "foo"; + column.name = "foo"; + column.type = StrictColumnType::Text; + column.constraints = {Sqlite::PrimaryKey{}}; + + column.clear(); + + ASSERT_THAT(column, + AllOf(Field(&Column::name, IsEmpty()), + Field(&Column::tableName, IsEmpty()), + Field(&Column::type, StrictColumnType::Any), + Field(&Column::constraints, IsEmpty()))); +} + +TEST_F(SqliteStrictColumn, Constructor) +{ + column = Column{"table", + "column", + StrictColumnType::Text, + {ForeignKey{"referencedTable", + "referencedColumn", + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred}}}; + + ASSERT_THAT(column, + AllOf(Field(&Column::name, Eq("column")), + Field(&Column::tableName, Eq("table")), + Field(&Column::type, StrictColumnType::Text), + Field(&Column::constraints, + ElementsAre(VariantWith<ForeignKey>( + AllOf(Field(&ForeignKey::table, Eq("referencedTable")), + Field(&ForeignKey::column, Eq("referencedColumn")), + Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull), + Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade), + Field(&ForeignKey::enforcement, Enforment::Deferred))))))); +} + +TEST_F(SqliteStrictColumn, FlatConstructor) +{ + column = Column{"table", + "column", + StrictColumnType::Text, + {ForeignKey{"referencedTable", + "referencedColumn", + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred}}}; + + ASSERT_THAT(column, + AllOf(Field(&Column::name, Eq("column")), + Field(&Column::tableName, Eq("table")), + Field(&Column::type, StrictColumnType::Text), + Field(&Column::constraints, + ElementsAre(VariantWith<ForeignKey>( + AllOf(Field(&ForeignKey::table, Eq("referencedTable")), + Field(&ForeignKey::column, Eq("referencedColumn")), + Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull), + Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade), + Field(&ForeignKey::enforcement, Enforment::Deferred))))))); +} + } // namespace diff --git a/tests/unit/unittest/sqlitetable-test.cpp b/tests/unit/unittest/sqlitetable-test.cpp index 20aa0680be..24be87cca4 100644 --- a/tests/unit/unittest/sqlitetable-test.cpp +++ b/tests/unit/unittest/sqlitetable-test.cpp @@ -32,7 +32,6 @@ namespace { -using Sqlite::Column; using Sqlite::ColumnType; using Sqlite::ConstraintType; using Sqlite::Database; @@ -41,10 +40,13 @@ using Sqlite::ForeignKey; using Sqlite::ForeignKeyAction; using Sqlite::JournalMode; using Sqlite::OpenMode; +using Sqlite::StrictColumnType; class SqliteTable : public ::testing::Test { protected: + using Column = Sqlite::Column; + NiceMock<SqliteDatabaseMock> databaseMock; Sqlite::Table table; Utils::SmallString tableName = "testTable"; @@ -328,4 +330,302 @@ TEST_F(SqliteTable, AddPrimaryTableContraint) table.initialize(databaseMock); } + +class StrictSqliteTable : public ::testing::Test +{ +protected: + using Column = Sqlite::StrictColumn; + + NiceMock<SqliteDatabaseMock> databaseMock; + Sqlite::StrictTable table; + Utils::SmallString tableName = "testTable"; +}; + +TEST_F(StrictSqliteTable, ColumnIsAddedToTable) +{ + table.setUseWithoutRowId(true); + + ASSERT_TRUE(table.useWithoutRowId()); +} + +TEST_F(StrictSqliteTable, SetTableName) +{ + table.setName(tableName.clone()); + + ASSERT_THAT(table.name(), tableName); +} + +TEST_F(StrictSqliteTable, SetUseWithoutRowid) +{ + table.setUseWithoutRowId(true); + + ASSERT_TRUE(table.useWithoutRowId()); +} + +TEST_F(StrictSqliteTable, AddIndex) +{ + table.setName(tableName.clone()); + auto &column = table.addColumn("name"); + auto &column2 = table.addColumn("value"); + + auto index = table.addIndex({column, column2}); + + ASSERT_THAT(Utils::SmallStringView(index.sqlStatement()), + Eq("CREATE INDEX IF NOT EXISTS index_testTable_name_value ON testTable(name, " + "value)")); +} + +TEST_F(StrictSqliteTable, InitializeTable) +{ + table.setName(tableName.clone()); + table.setUseIfNotExists(true); + table.setUseTemporaryTable(true); + table.setUseWithoutRowId(true); + table.addColumn("name"); + table.addColumn("value"); + + EXPECT_CALL(databaseMock, + execute(Eq("CREATE TEMPORARY TABLE IF NOT EXISTS testTable(name ANY, value ANY) " + "WITHOUT ROWID STRICT"))); + + table.initialize(databaseMock); +} + +TEST_F(StrictSqliteTable, InitializeTableWithIndex) +{ + InSequence sequence; + table.setName(tableName.clone()); + auto &column = table.addColumn("name"); + auto &column2 = table.addColumn("value"); + table.addIndex({column}); + table.addIndex({column2}, "value IS NOT NULL"); + + EXPECT_CALL(databaseMock, execute(Eq("CREATE TABLE testTable(name ANY, value ANY) STRICT"))); + EXPECT_CALL(databaseMock, + execute(Eq("CREATE INDEX IF NOT EXISTS index_testTable_name ON testTable(name)"))); + EXPECT_CALL(databaseMock, + execute(Eq("CREATE INDEX IF NOT EXISTS index_testTable_value ON testTable(value) " + "WHERE value IS NOT NULL"))); + + table.initialize(databaseMock); +} + +TEST_F(StrictSqliteTable, InitializeTableWithUniqueIndex) +{ + InSequence sequence; + table.setName(tableName.clone()); + auto &column = table.addColumn("name"); + auto &column2 = table.addColumn("value"); + table.addUniqueIndex({column}); + table.addUniqueIndex({column2}, "value IS NOT NULL"); + + EXPECT_CALL(databaseMock, execute(Eq("CREATE TABLE testTable(name ANY, value ANY) STRICT"))); + EXPECT_CALL(databaseMock, + execute(Eq( + "CREATE UNIQUE INDEX IF NOT EXISTS index_testTable_name ON testTable(name)"))); + EXPECT_CALL(databaseMock, + execute(Eq( + "CREATE UNIQUE INDEX IF NOT EXISTS index_testTable_value ON testTable(value) " + "WHERE value IS NOT NULL"))); + + table.initialize(databaseMock); +} + +TEST_F(StrictSqliteTable, AddForeignKeyColumnWithTableCalls) +{ + Sqlite::StrictTable foreignTable; + foreignTable.setName("foreignTable"); + table.setName(tableName); + table.addForeignKeyColumn("name", + foreignTable, + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred); + + EXPECT_CALL(databaseMock, + execute(Eq("CREATE TABLE testTable(name INTEGER REFERENCES foreignTable ON UPDATE " + "SET NULL ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED) STRICT"))); + + table.initialize(databaseMock); +} + +TEST_F(StrictSqliteTable, AddForeignKeyColumnWithColumnCalls) +{ + Sqlite::StrictTable foreignTable; + foreignTable.setName("foreignTable"); + auto &foreignColumn = foreignTable.addColumn("foreignColumn", + StrictColumnType::Text, + {Sqlite::Unique{}}); + table.setName(tableName); + table.addForeignKeyColumn("name", + foreignColumn, + ForeignKeyAction::SetDefault, + ForeignKeyAction::Restrict, + Enforment::Deferred); + + EXPECT_CALL( + databaseMock, + execute( + Eq("CREATE TABLE testTable(name TEXT REFERENCES foreignTable(foreignColumn) ON UPDATE " + "SET DEFAULT ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED) STRICT"))); + + table.initialize(databaseMock); +} + +TEST_F(StrictSqliteTable, AddColumn) +{ + table.setName(tableName); + + auto &column = table.addColumn("name", StrictColumnType::Text, {Sqlite::Unique{}}); + + ASSERT_THAT(column, + AllOf(Field(&Column::name, Eq("name")), + Field(&Column::tableName, Eq(tableName)), + Field(&Column::type, StrictColumnType::Text), + Field(&Column::constraints, + ElementsAre(VariantWith<Sqlite::Unique>(Eq(Sqlite::Unique{})))))); +} + +TEST_F(StrictSqliteTable, AddForeignKeyColumnWithTable) +{ + Sqlite::StrictTable 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, StrictColumnType::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(StrictSqliteTable, AddForeignKeyColumnWithColumn) +{ + Sqlite::StrictTable foreignTable; + foreignTable.setName("foreignTable"); + auto &foreignColumn = foreignTable.addColumn("foreignColumn", + StrictColumnType::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, StrictColumnType::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(StrictSqliteTable, AddForeignKeyWhichIsNotUniqueThrowsAnExceptions) +{ + Sqlite::StrictTable foreignTable; + foreignTable.setName("foreignTable"); + auto &foreignColumn = foreignTable.addColumn("foreignColumn", StrictColumnType::Text); + table.setName(tableName); + + ASSERT_THROW(table.addForeignKeyColumn("name", + foreignColumn, + ForeignKeyAction::SetNull, + ForeignKeyAction::Cascade, + Enforment::Deferred), + Sqlite::ForeignKeyColumnIsNotUnique); +} + +TEST_F(StrictSqliteTable, AddForeignKeyColumnWithTableAndNotNull) +{ + Sqlite::StrictTable 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, StrictColumnType::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(StrictSqliteTable, AddForeignKeyColumnWithColumnAndNotNull) +{ + Sqlite::StrictTable foreignTable; + foreignTable.setName("foreignTable"); + auto &foreignColumn = foreignTable.addColumn("foreignColumn", + StrictColumnType::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, StrictColumnType::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(StrictSqliteTable, AddPrimaryTableContraint) +{ + table.setName(tableName.clone()); + const auto &idColumn = table.addColumn("id"); + const auto &nameColumn = table.addColumn("name"); + table.addPrimaryKeyContraint({idColumn, nameColumn}); + + EXPECT_CALL(databaseMock, + execute( + Eq("CREATE TABLE testTable(id ANY, name ANY, PRIMARY KEY(id, name)) STRICT"))); + + table.initialize(databaseMock); +} } // namespace diff --git a/tests/unit/unittest/sqlstatementbuilder-test.cpp b/tests/unit/unittest/sqlstatementbuilder-test.cpp index 1e24faeded..806939fcdb 100644 --- a/tests/unit/unittest/sqlstatementbuilder-test.cpp +++ b/tests/unit/unittest/sqlstatementbuilder-test.cpp @@ -135,16 +135,6 @@ TEST(SqlStatementBuilder, ClearBinding) ASSERT_THROW(sqlStatementBuilder.sqlStatement(), SqlStatementBuilderException); } -TEST(SqlStatementBuilder, ColumnType) -{ - ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Numeric), " NUMERIC"); - ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Integer), " INTEGER"); - ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Real), " REAL"); - ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Text), " TEXT"); - ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Blob), " BLOB"); - ASSERT_TRUE(SqlStatementBuilder::columnTypeToString(ColumnType::None).isEmpty()); -} - TEST(SqlStatementBuilder, SqlStatementFailure) { SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table"); |