Added integrity violation tests.

Author: Ja bist du narrisch

src/Migrator.Tests/Providers/SQLite/SQLiteTransformationProviderAddForeignKeyTests.cs

@@ -0,0 +1,91 @@
+#region License
+
+//The contents of this file are subject to the Mozilla Public License
+//Version 1.1 (the "License"); you may not use this file except in
+//compliance with the License. You may obtain a copy of the License at
+//http://www.mozilla.org/MPL/
+//Software distributed under the License is distributed on an "AS IS"
+//basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+//License for the specific language governing rights and limitations
+//under the License.
+
+#endregion
+
+using System.Linq;
+using DotNetProjects.Migrator.Framework;
+using DotNetProjects.Migrator.Providers.Impl.SQLite;
+using Migrator.Providers.SQLite;
+using Migrator.Tests.Settings;
+using NUnit.Framework;
+
+namespace Migrator.Tests.Providers;
+
+[TestFixture]
+[Category("SQLite")]
+public class SQLiteTransformationProviderAddForeignKeyTests : TransformationProviderBase
+{
+    [SetUp]
+    public void SetUp()
+    {
+        var configReader = new ConfigurationReader();
+        var connectionString = configReader.GetDatabaseConnectionConfigById("SQLiteConnectionString")
+            .ConnectionString;
+
+        _provider = new SQLiteTransformationProvider(new SQLiteDialect(), connectionString, "default", null);
+        _provider.BeginTransaction();
+
+        AddDefaultTable();
+    }
+
+    [Test]
+    public void AddForeignKey()
+    {
+        // Arrange
+        AddTableWithPrimaryKey();
+        _provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
+        _provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
+
+        // Act
+        _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
+
+        // Assert
+        var foreignKeyConstraints = ((SQLiteTransformationProvider)_provider).GetForeignKeyConstraints("TestTwo");
+        var tableSQLCreateScript = ((SQLiteTransformationProvider)_provider).GetSqlCreateTableScript("TestTwo");
+
+        Assert.That(foreignKeyConstraints.Single().Name, Is.Null);
+        Assert.That(foreignKeyConstraints.Single().ChildTable, Is.EqualTo("TestTwo"));
+        Assert.That(foreignKeyConstraints.Single().ParentTable, Is.EqualTo("Test"));
+        Assert.That(foreignKeyConstraints.Single().ChildColumns.Single(), Is.EqualTo("TestId"));
+        Assert.That(foreignKeyConstraints.Single().ParentColumns.Single(), Is.EqualTo("Id"));
+        // Cascade is not supported
+
+        Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
+        Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(Id))"));
+
+        var result = ((SQLiteTransformationProvider)_provider).CheckForeignKeyIntegrity();
+        Assert.That(result, Is.True);
+    }
+
+    [Test]
+    public void AddForeignKey_RenameParentColumWithForeignKeyAndData_ForeignKeyPointsToRenamedColumn()
+    {
+        // Arrange
+        AddTableWithPrimaryKey();
+        _provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
+        _provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
+        _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
+
+        // Act
+        _provider.RenameColumn("Test", "Id", "IdNew");
+
+        // Assert
+        var foreignKeyConstraints = ((SQLiteTransformationProvider)_provider).GetForeignKeyConstraints("TestTwo");
+        var tableSQLCreateScript = ((SQLiteTransformationProvider)_provider).GetSqlCreateTableScript("TestTwo");
+
+        Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
+        Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(Id))"));
+
+        var result = ((SQLiteTransformationProvider)_provider).CheckForeignKeyIntegrity();
+        Assert.That(result, Is.True);
+    }
+}

src/Migrator.Tests/Providers/SQLiteTransformationProviderTest.cs

@@ -11,7 +11,6 @@
 
 #endregion
 
-using System.Linq;
 using DotNetProjects.Migrator.Framework;
 using DotNetProjects.Migrator.Providers.Impl.SQLite;
 using Migrator.Providers.SQLite;
@@ -38,29 +37,37 @@ public void SetUp()
         }
 
         [Test]
-        public void AddForeignKey()
+        public void CheckForeignKeyIntegrity_IntegrityViolated_ReturnsFalse()
         {
             // Arrange
             AddTableWithPrimaryKey();
+            _provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
+            _provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (44444)");
+            _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
 
             // Act
-            _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
+            var result = ((SQLiteTransformationProvider)_provider).CheckForeignKeyIntegrity();
 
             // Assert
-            var foreignKeyConstraints = ((SQLiteTransformationProvider)_provider).GetForeignKeyConstraints("TestTwo");
-            var tableSQLCreateScript = ((SQLiteTransformationProvider)_provider).GetSqlCreateTableScript("TestTwo");
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void CheckForeignKeyIntegrity_IntegrityOk_ReturnsTrue()
+        {
+            // Arrange
+            AddTableWithPrimaryKey();
+            _provider.ExecuteNonQuery("INSERT INTO Test (Id, name) VALUES (1, 'my name')");
+            _provider.ExecuteNonQuery("INSERT INTO TestTwo (TestId) VALUES (1)");
+            _provider.AddForeignKey("FK name is not supported by SQLite", parentTable: "Test", parentColumn: "Id", childTable: "TestTwo", childColumn: "TestId", ForeignKeyConstraintType.Cascade);
 
-            Assert.That(foreignKeyConstraints.Single().Name, Is.Null);
-            Assert.That(foreignKeyConstraints.Single().ChildTable, Is.EqualTo("TestTwo"));
-            Assert.That(foreignKeyConstraints.Single().ParentTable, Is.EqualTo("Test"));
-            Assert.That(foreignKeyConstraints.Single().ChildColumns.Single(), Is.EqualTo("TestId"));
-            Assert.That(foreignKeyConstraints.Single().ParentColumns.Single(), Is.EqualTo("Id"));
+            // Act
+            var result = ((SQLiteTransformationProvider)_provider).CheckForeignKeyIntegrity();
 
-            Assert.That(tableSQLCreateScript, Does.Contain("CREATE TABLE \"TestTwo\""));
-            Assert.That(tableSQLCreateScript, Does.Contain(", FOREIGN KEY (TestId) REFERENCES Test(Id))"));
+            // Assert
+            Assert.That(result, Is.True);
         }
 
-
         [Test]
         public void CanParseColumnDefForName()
         {

src/Migrator/Providers/Impl/SQLite/SQLiteTransformationProvider.cs

@@ -310,17 +310,34 @@ public override void RemoveColumn(string table, string column)
 
         public override void RenameColumn(string tableName, string oldColumnName, string newColumnName)
         {
+            // Due to old .Net versions we cannot use ThrowIfNullOrWhitespace
+            if (string.IsNullOrWhiteSpace(newColumnName))
+            {
+                throw new Exception("New column name is null or empty");
+            }
+
             if (ColumnExists(tableName, newColumnName))
             {
                 throw new MigrationException(string.Format("Table '{0}' has column named '{1}' already", tableName, newColumnName));
             }
 
             if (ColumnExists(tableName, oldColumnName))
             {
-                var columnDef = GetColumns(tableName).First(x => x.Name == oldColumnName);
+                var sqliteTableInfo = GetTableData(tableName);
+                var columnMapping = sqliteTableInfo.ColumnMappings.First(x => x.OldName == oldColumnName);
+                columnMapping.NewName = newColumnName;
+
+                var column = sqliteTableInfo.Columns.First(x => x.Name == newColumnName);
+                column.Name = newColumnName;
+
+                var affectedForeignKeys = sqliteTableInfo.ForeignKeys.Where(x => x.ChildColumns.Contains(oldColumnName)).ToList();
 
-                columnDef.Name = newColumnName;
-                ChangeColumnInternal(tableName, [oldColumnName], [columnDef]);
+                foreach (var foreignKey in affectedForeignKeys)
+                {
+                    foreignKey.ChildColumns = foreignKey.ChildColumns.Select(x => x == oldColumnName ? newColumnName : x).ToArray();
+                }
+
+                RecreateTable(sqliteTableInfo);
             }
             else
             {
@@ -379,18 +396,34 @@ public SQLiteTableInfo GetTableData(string tableName)
             return sqliteTable;
         }
 
+        public bool CheckForeignKeyIntegrity()
+        {
+            ExecuteNonQuery("PRAGMA foreign_keys = ON");
+
+            using (var cmd = CreateCommand())
+            using (var reader = ExecuteQuery(cmd, "PRAGMA foreign_key_check"))
+            {
+                if (reader.Read())
+                {
+                    return false;
+                }
+
+                return true;
+            }
+        }
+
         private void RecreateTable(SQLiteTableInfo sqliteTableInfo)
         {
             var sourceTableQuoted = QuoteTableNameIfRequired(sqliteTableInfo.TableNameMapping.OldName);
             var targetIntermediateTableQuoted = QuoteTableNameIfRequired($"{sqliteTableInfo.TableNameMapping.NewName}{IntermediateTableSuffix}");
             var targetTableQuoted = QuoteTableNameIfRequired($"{sqliteTableInfo.TableNameMapping.NewName}");
 
-            var columns = sqliteTableInfo.Columns.Cast<IDbField>();
-            var foreignKeys = sqliteTableInfo.ForeignKeys.Cast<IDbField>();
-            var indexes = sqliteTableInfo.Indexes.Cast<IDbField>();
+            var columnDbFields = sqliteTableInfo.Columns.Cast<IDbField>();
+            var foreignKeyDbFields = sqliteTableInfo.ForeignKeys.Cast<IDbField>();
+            var indexDbFields = sqliteTableInfo.Indexes.Cast<IDbField>();
 
-            var dbFields = columns.Concat(foreignKeys)
-                .Concat(indexes)
+            var dbFields = columnDbFields.Concat(foreignKeyDbFields)
+                .Concat(indexDbFields)
                 .ToArray();
 
             AddTable(targetIntermediateTableQuoted, null, dbFields);