aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/unit/unittest/createtablesqlstatementbuilder-test.cpp635
-rw-r--r--tests/unit/unittest/sqlitecolumn-test.cpp128
-rw-r--r--tests/unit/unittest/sqlitetable-test.cpp302
-rw-r--r--tests/unit/unittest/sqlstatementbuilder-test.cpp10
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");
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 16:48:33 +0000