Merge pull request fluentmigrator#158 of guillaume86/master

* guillaume86-master: Ignoring the NCrunch configuration files. Building the tests for foreign key OnUpdate, OnDelete, and OnDeleteAndUpdate builders and expressions. Add the Cascade syntax to the new ForeignKey creation syntax. correct the obsolete messages on the concrete types
rebootd · Jan 30, 2012 · 8321066 · 8321066
2 parents 413f003 + 6fb08dc
commit 8321066
Show file tree

Hide file tree

Showing 27 changed files with 879 additions and 307 deletions.
diff --git a/.gitignore b/.gitignore
@@ -23,4 +23,5 @@ src/*.vs10x
 *.vs10x
 src/FluentMigrator.Tests/FluentMigrator.VisualState.xml
 examplecommand.txt
-*.dotsettings.user
+*.crunchproject.local.xml
+*.crunchsolution.local.xml
diff --git a/src/FluentMigrator.Tests/Unit/Builders/Alter/AlterColumnExpressionBuilderTests.cs b/src/FluentMigrator.Tests/Unit/Builders/Alter/AlterColumnExpressionBuilderTests.cs
@@ -1,3 +1,21 @@
+#region License
+// 
+// Copyright (c) 2007-2009, Sean Chambers <schambers80@gmail.com>
+// 
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -460,6 +478,33 @@ public void CallingReferencedByAddsNewForeignKeyExpressionToContext()
             contextMock.VerifyGet(x => x.Expressions);
         }
 
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnUpdateSetsOnUpdateOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterColumnExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(Rule.None));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteSetsOnDeleteOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterColumnExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDelete(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(Rule.None));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteOrUpdateSetsOnUpdateAndOnDeleteOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterColumnExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDeleteOrUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
         [Test]
         public void CallingUniqueAddsIndexExpressionToContext()
         {
@@ -580,4 +625,4 @@ public void CallingWithDefaultAddsAlterDefaultConstraintExpression()
             contextMock.VerifyGet(x => x.Expressions);
         }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Builders/Alter/AlterTableExpressionBuilderTests.cs b/src/FluentMigrator.Tests/Unit/Builders/Alter/AlterTableExpressionBuilderTests.cs
@@ -377,6 +377,33 @@ public void CallingForeignKeyAddsNewForeignKeyExpressionToContext()
             contextMock.VerifyGet(x => x.Expressions);
         }
 
+    [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnUpdateSetsOnUpdateOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(Rule.None));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteSetsOnDeleteOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDelete(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(Rule.None));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteOrUpdateSetsOnUpdateAndOnDeleteOnForeignKeyExpression(Rule rule)
+        {
+            var builder = new AlterTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDeleteOrUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
         [Test]
         public void CallingIdentitySetsIsIdentityToTrue()
         {

diff --git a/src/FluentMigrator.Tests/Unit/Builders/Create/CreateColumnExpressionBuilderTests.cs b/src/FluentMigrator.Tests/Unit/Builders/Create/CreateColumnExpressionBuilderTests.cs
@@ -550,6 +550,33 @@ public void CallingForeignKeyAddsNewForeignKeyExpressionToContext()
                                                 )));
         }
 
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnUpdateSetsOnUpdateOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateColumnExpressionBuilder(null, null) {CurrentForeignKey = new ForeignKeyDefinition()};
+            builder.OnUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(Rule.None));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteSetsOnDeleteOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateColumnExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDelete(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(Rule.None));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteOrUpdateSetsOnUpdateAndOnDeleteOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateColumnExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDeleteOrUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
         private void VerifyColumnProperty(Action<ColumnDefinition> columnExpression, Action<CreateColumnExpressionBuilder> callToTest)
         {
             var columnMock = new Mock<ColumnDefinition>();
@@ -619,4 +646,4 @@ private void VerifyColumnPrecision(int expected, Action<CreateColumnExpressionBu
             columnMock.VerifySet(c => c.Precision = expected);
         }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Builders/Create/CreateForeignKeyExpressionBuilderTests.cs b/src/FluentMigrator.Tests/Unit/Builders/Create/CreateForeignKeyExpressionBuilderTests.cs
@@ -17,6 +17,7 @@
 #endregion
 
 using System.Collections.Generic;
+using System.Data;
 using FluentMigrator.Builders.Create.ForeignKey;
 using FluentMigrator.Expressions;
 using FluentMigrator.Model;
@@ -135,5 +136,35 @@ public void CallingPrimaryColumnsAddsColumnNamesToForeignColumnCollection()
             foreignKeyMock.VerifyGet(f => f.PrimaryColumns);
             expressionMock.VerifyGet(e => e.ForeignKey);
         }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnUpdateSetsOnUpdateToSpecifiedRule(Rule rule) 
+        {
+            var expression = new CreateForeignKeyExpression();
+            var builder = new CreateForeignKeyExpressionBuilder(expression);
+            builder.OnUpdate(rule);
+            Assert.That(expression.ForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(expression.ForeignKey.OnDelete, Is.EqualTo(Rule.None));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteSetsOnDeleteToSpecifiedRule(Rule rule) 
+        {
+            var expression = new CreateForeignKeyExpression();
+            var builder = new CreateForeignKeyExpressionBuilder(expression);
+            builder.OnDelete(rule);
+            Assert.That(expression.ForeignKey.OnUpdate, Is.EqualTo(Rule.None));
+            Assert.That(expression.ForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteOrUpdateSetsBothOnDeleteAndOnUpdateToSpecifiedRule(Rule rule) 
+        {
+            var expression = new CreateForeignKeyExpression();
+            var builder = new CreateForeignKeyExpressionBuilder(expression);
+            builder.OnDeleteOrUpdate(rule);
+            Assert.That(expression.ForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(expression.ForeignKey.OnDelete, Is.EqualTo(rule));
+        }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Builders/Create/CreateTableExpressionBuilderTests.cs b/src/FluentMigrator.Tests/Unit/Builders/Create/CreateTableExpressionBuilderTests.cs
@@ -528,6 +528,33 @@ public void CallingForeignKeyAddsNewForeignKeyExpressionToContext()
             contextMock.VerifyGet(x => x.Expressions);
         }
 
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnUpdateSetsOnUpdateOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(Rule.None));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteSetsOnDeleteOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDelete(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(Rule.None));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
+        [TestCase(Rule.Cascade), TestCase(Rule.SetDefault), TestCase(Rule.SetNull), TestCase(Rule.None)]
+        public void CallingOnDeleteOrUpdateSetsOnUpdateAndOnDeleteOnForeignKeyExpression(Rule rule) 
+        {
+            var builder = new CreateTableExpressionBuilder(null, null) { CurrentForeignKey = new ForeignKeyDefinition() };
+            builder.OnDeleteOrUpdate(rule);
+            Assert.That(builder.CurrentForeignKey.OnUpdate, Is.EqualTo(rule));
+            Assert.That(builder.CurrentForeignKey.OnDelete, Is.EqualTo(rule));
+        }
+
         [Test]
         public void CallingWithColumnAddsNewColumnToExpression()
         {
@@ -612,4 +639,4 @@ private void VerifyColumnPrecision(int expected, Action<CreateTableExpressionBui
             columnMock.VerifySet(c => c.Precision = expected);
         }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Generators/Jet/JetAlterTableTests.cs b/src/FluentMigrator.Tests/Unit/Generators/Jet/JetAlterTableTests.cs
@@ -1,4 +1,5 @@
-using FluentMigrator.Expressions;
+using System.Data;
+using FluentMigrator.Expressions;
 using FluentMigrator.Runner.Generators;
 using FluentMigrator.Runner.Generators.Jet;
 using NUnit.Framework;
@@ -50,6 +51,37 @@ public override void CanCreateForeignKey()
                 "ALTER TABLE [TestTable1] ADD CONSTRAINT [FK_Test] FOREIGN KEY ([TestColumn1]) REFERENCES [TestTable2] ([TestColumn2])");
         }
 
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnUpdateOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnUpdate = rule;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE [TestTable1] ADD CONSTRAINT [FK_Test] FOREIGN KEY ([TestColumn1]) REFERENCES [TestTable2] ([TestColumn2]) ON UPDATE {0}", output));
+        }
+
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnDeleteOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = rule;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE [TestTable1] ADD CONSTRAINT [FK_Test] FOREIGN KEY ([TestColumn1]) REFERENCES [TestTable2] ([TestColumn2]) ON DELETE {0}", output));
+        }
+
+        [Test]
+        public void CanCreateForeignKeyWithOnDeleteAndOnUpdateOptions() 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = Rule.Cascade;
+            expression.ForeignKey.OnUpdate = Rule.SetDefault;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                "ALTER TABLE [TestTable1] ADD CONSTRAINT [FK_Test] FOREIGN KEY ([TestColumn1]) REFERENCES [TestTable2] ([TestColumn2]) ON DELETE CASCADE ON UPDATE SET DEFAULT");
+        }
+
         [Test]
         public override void CanCreateMulitColumnForeignKey()
         {
@@ -135,4 +167,4 @@ public void CanCreateMultiColmnNamedUniqueConstraint()
             result.ShouldBe("ALTER TABLE [TestTable1] ADD CONSTRAINT [TESTUNIQUECONSTRAINT] UNIQUE ([TestColumn1], [TestColumn2])");
         }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Generators/MySql/MySqlAlterTableTestscs.cs b/src/FluentMigrator.Tests/Unit/Generators/MySql/MySqlAlterTableTestscs.cs
@@ -1,4 +1,5 @@
-using FluentMigrator.Expressions;
+using System.Data;
+using FluentMigrator.Expressions;
 using FluentMigrator.Runner.Generators;
 using FluentMigrator.Runner.Generators.MySql;
 using NUnit.Framework;
@@ -70,6 +71,37 @@ public override void CanCreateForeignKey()
                 "ALTER TABLE `TestTable1` ADD CONSTRAINT `FK_Test` FOREIGN KEY (`TestColumn1`) REFERENCES `TestTable2` (`TestColumn2`)");
         }
 
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnUpdateOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnUpdate = rule;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE `TestTable1` ADD CONSTRAINT `FK_Test` FOREIGN KEY (`TestColumn1`) REFERENCES `TestTable2` (`TestColumn2`) ON UPDATE {0}", output));
+        }
+
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnDeleteOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = rule;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE `TestTable1` ADD CONSTRAINT `FK_Test` FOREIGN KEY (`TestColumn1`) REFERENCES `TestTable2` (`TestColumn2`) ON DELETE {0}", output));
+        }
+
+        [Test]
+        public void CanCreateForeignKeyWithOnDeleteAndOnUpdateOptions() 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = Rule.Cascade;
+            expression.ForeignKey.OnUpdate = Rule.SetDefault;
+            var sql = _generator.Generate(expression);
+            sql.ShouldBe(
+                "ALTER TABLE `TestTable1` ADD CONSTRAINT `FK_Test` FOREIGN KEY (`TestColumn1`) REFERENCES `TestTable2` (`TestColumn2`) ON DELETE CASCADE ON UPDATE SET DEFAULT");
+        }
+
         [Test]
         public override void CanCreateMulitColumnForeignKey()
         {
@@ -192,4 +224,4 @@ public void CanDropForiegnKeyConstraint()
             result.ShouldBe("ALTER TABLE `TestTable1` DROP FOREIGN KEY `FK_Test`");
         }
     }
-}
+}
diff --git a/src/FluentMigrator.Tests/Unit/Generators/Oracle/OracleAlterTableTests.cs b/src/FluentMigrator.Tests/Unit/Generators/Oracle/OracleAlterTableTests.cs
@@ -1,4 +1,5 @@
-using FluentMigrator.Expressions;
+using System.Data;
+using FluentMigrator.Expressions;
 using FluentMigrator.Runner.Generators;
 using FluentMigrator.Runner.Generators.Oracle;
 using NUnit.Framework;
@@ -62,6 +63,38 @@ public override void CanCreateForeignKey()
             var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
             string sql = generator.Generate(expression);
             sql.ShouldBe("ALTER TABLE TestTable1 ADD CONSTRAINT FK_Test FOREIGN KEY (TestColumn1) REFERENCES TestTable2 (TestColumn2)");
+
+        }
+
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnUpdateOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnUpdate = rule;
+            var sql = generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE TestTable1 ADD CONSTRAINT FK_Test FOREIGN KEY (TestColumn1) REFERENCES TestTable2 (TestColumn2) ON UPDATE {0}", output));
+        }
+
+        [TestCase(Rule.SetDefault, "SET DEFAULT"), TestCase(Rule.SetNull, "SET NULL"), TestCase(Rule.Cascade, "CASCADE")]
+        public void CanCreateForeignKeyWithOnDeleteOptions(Rule rule, string output) 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = rule;
+            var sql = generator.Generate(expression);
+            sql.ShouldBe(
+                string.Format("ALTER TABLE TestTable1 ADD CONSTRAINT FK_Test FOREIGN KEY (TestColumn1) REFERENCES TestTable2 (TestColumn2) ON DELETE {0}", output));
+        }
+
+        [Test]
+        public void CanCreateForeignKeyWithOnDeleteAndOnUpdateOptions() 
+        {
+            var expression = GeneratorTestHelper.GetCreateForeignKeyExpression();
+            expression.ForeignKey.OnDelete = Rule.Cascade;
+            expression.ForeignKey.OnUpdate = Rule.SetDefault;
+            var sql = generator.Generate(expression);
+            sql.ShouldBe(
+                "ALTER TABLE TestTable1 ADD CONSTRAINT FK_Test FOREIGN KEY (TestColumn1) REFERENCES TestTable2 (TestColumn2) ON DELETE CASCADE ON UPDATE SET DEFAULT");
         }
 
         [Test]
@@ -172,4 +205,4 @@ public void CanCreateMultiColumnNamedUniqueConstraint()
             result.ShouldBe("ALTER TABLE TestTable1 ADD CONSTRAINT TESTUNIQUECONSTRAINT UNIQUE (TestColumn1, TestColumn2)");
         }
     }
-}
+}