public void CallingUniqueNamedAddsIndexExpressionToContext()
        {
            var collectionMock = new Mock <ICollection <IMigrationExpression> >();

            var contextMock = new Mock <IMigrationContext>();

            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var columnMock = new Mock <ColumnDefinition>();

            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupGet(x => x.SchemaName).Returns("Eggs");
            expressionMock.SetupGet(x => x.TableName).Returns("Bacon");
            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.Unique("IX_Bacon_BaconId");

            collectionMock.Verify(x => x.Add(It.Is <CreateIndexExpression>(
                                                 ix => ix.Index.Name == "IX_Bacon_BaconId" &&
                                                 ix.Index.TableName == "Bacon" &&
                                                 ix.Index.SchemaName == "Eggs" &&
                                                 ix.Index.IsUnique &&
                                                 !ix.Index.IsClustered &&
                                                 ix.Index.Columns.All(c => c.Name == "BaconId")
                                                 )));

            contextMock.VerifyGet(x => x.Expressions);
        }
Exemple #2
0
        private static ISupportAdditionalFeatures GetColumn <TNext, TNextFk>(IColumnOptionSyntax <TNext, TNextFk> expression) where TNext : IFluentSyntax where TNextFk : IFluentSyntax
        {
            CreateTableExpressionBuilder cast1 = expression as CreateTableExpressionBuilder;

            if (cast1 != null)
            {
                return(cast1.CurrentColumn);
            }

            AlterTableExpressionBuilder cast2 = expression as AlterTableExpressionBuilder;

            if (cast2 != null)
            {
                return(cast2.CurrentColumn);
            }

            AlterColumnExpressionBuilder cast3 = expression as AlterColumnExpressionBuilder;

            if (cast3 != null)
            {
                return(cast3.GetColumnForType());
            }

            CreateColumnExpressionBuilder cast4 = expression as CreateColumnExpressionBuilder;

            if (cast4 != null)
            {
                return(cast4.GetColumnForType());
            }

            throw new InvalidOperationException("The seeded identity method can only be called on a valid object.");
        }
        public void CallingForeignKeyAddsNewForeignKeyExpressionToContext()
        {
            var collectionMock = new Mock <ICollection <IMigrationExpression> >();

            var contextMock = new Mock <IMigrationContext>();

            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var columnMock = new Mock <ColumnDefinition>();

            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupGet(x => x.TableName).Returns("Bacon");
            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.ForeignKey("fk_foo", "FooTable", "BarColumn");

            contextMock.VerifyGet(x => x.Expressions);
            collectionMock.Verify(x => x.Add(It.Is <CreateForeignKeyExpression>(
                                                 fk => fk.ForeignKey.Name == "fk_foo" &&
                                                 fk.ForeignKey.PrimaryTable == "FooTable" &&
                                                 fk.ForeignKey.PrimaryColumns.Contains("BarColumn") &&
                                                 fk.ForeignKey.PrimaryColumns.Count == 1 &&
                                                 fk.ForeignKey.ForeignTable == "Bacon" &&
                                                 fk.ForeignKey.ForeignColumns.Contains("BaconId") &&
                                                 fk.ForeignKey.ForeignColumns.Count == 1
                                                 )));
        }
        public void CallingGeneratedIdentityMinMaxSetsAdditionalProperties()
        {
            var contextMock = new Mock <IMigrationContext>();

            var columnMock = new Mock <ColumnDefinition>();

            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.Identity(OracleGenerationType.Always, startWith: 0, incrementBy: 1, minValue: 0, long.MaxValue);

            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(OracleExtensions.IdentityGeneration, OracleGenerationType.Always));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(OracleExtensions.IdentityStartWith, 0L));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(OracleExtensions.IdentityIncrementBy, 1));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(OracleExtensions.IdentityMinValue, 0L));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(OracleExtensions.IdentityMaxValue, long.MaxValue));
        }
 /// <summary>
 /// Initialize object from the <see cref="CreateColumnExpressionBuilder"/> object
 /// </summary>
 /// <param name="builder">The <see cref="CreateColumnExpressionBuilder"/> object</param>
 /// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
 public ChangeLogLinkedExpression(CreateColumnExpressionBuilder builder, ChangeLogContext changeLog)
     : this(changeLog, builder.Expression)
 {
     GetColumns = () => new List <ColumnDefinition> {
         builder.Expression.Column
     };
     SchemaName = builder.Expression.SchemaName;
     TableName  = builder.Expression.TableName;
 }
        public void ColumnHelperSetOnCreation()
        {
            var expressionMock = new Mock <CreateColumnExpression>();
            var contextMock    = new Mock <IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            Assert.IsNotNull(builder.ColumnHelper);
        }
        public void CallingOnTableSetsTableName()
        {
            var expressionMock = new Mock<CreateColumnExpression>();

            var contextMock = new Mock<IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            builder.OnTable("Bacon");

            expressionMock.VerifySet(x => x.TableName = "Bacon");
        }
        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));
        }
        public void CallingOnTableSetsTableName()
        {
            var expressionMock = new Mock <CreateColumnExpression>();

            var contextMock = new Mock <IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.OnTable("Bacon");

            expressionMock.VerifySet(x => x.TableName = "Bacon");
        }
        public void ColumnExpressionBuilderUsesExpressionColumn()
        {
            var expressionMock = new Mock <CreateColumnExpression>();
            var contextMock    = new Mock <IMigrationContext>();
            var curColumn      = new Mock <ColumnDefinition>().Object;

            expressionMock.SetupGet(n => n.Column).Returns(curColumn);

            var builder            = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            var builderAsInterface = (IColumnExpressionBuilder)builder;

            Assert.AreSame(curColumn, builderAsInterface.Column);
        }
        public void ColumnExpressionBuilderUsesExpressionColumnSchemaAndTableName()
        {
            var expressionMock = new Mock <CreateColumnExpression>();
            var contextMock    = new Mock <IMigrationContext>();

            expressionMock.SetupGet(n => n.SchemaName).Returns("Fred");
            expressionMock.SetupGet(n => n.TableName).Returns("Flinstone");

            var builder            = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            var builderAsInterface = (IColumnExpressionBuilder)builder;

            Assert.AreEqual("Fred", builderAsInterface.SchemaName);
            Assert.AreEqual("Flinstone", builderAsInterface.TableName);
        }
        private void VerifyColumnHelperCall(Action <CreateColumnExpressionBuilder> callToTest, System.Linq.Expressions.Expression <Action <ColumnExpressionBuilderHelper> > expectedHelperAction)
        {
            var expressionMock = new Mock <CreateColumnExpression>();
            var contextMock    = new Mock <IMigrationContext>();
            var helperMock     = new Mock <ColumnExpressionBuilderHelper>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.ColumnHelper = helperMock.Object;

            callToTest(builder);

            helperMock.Verify(expectedHelperAction);
        }
        public static ICollection <IMigrationExpression> GetCreateColumnWithSystemMethodExpression(string schemaName = null)
        {
            var context = new MigrationContext(null, null, null, null);
            var expr    = new CreateColumnExpression
            {
                TableName  = TestTableName1,
                SchemaName = schemaName,
                Column     = new ColumnDefinition {
                    Name = TestColumnName1, Type = DbType.String, Size = 5
                }
            };

            context.Expressions.Add(expr);
            var builder = new CreateColumnExpressionBuilder(expr, context);

            builder.SetExistingRowsTo(SystemMethods.CurrentDateTime);
            return(context.Expressions);
        }
Exemple #14
0
        public void CallingPostgresGeneratedIdentitySetsAdditionalProperties()
        {
            var contextMock = new Mock <IMigrationContext>();

            var columnMock = new Mock <ColumnDefinition>();

            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.Identity(PostgresGenerationType.Always);

            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(PostgresExtensions.IdentityGeneration, PostgresGenerationType.Always));
        }
Exemple #15
0
        public static ICollection <IMigrationExpression> GetCreateColumnWithSystemMethodExpression(string schemaName = null)
        {
            var serviceProvider = new ServiceCollection().BuildServiceProvider();
            var querySchema     = new Mock <IQuerySchema>();
            var context         = new MigrationContext(querySchema.Object, serviceProvider, null, null);
            var expr            = new CreateColumnExpression
            {
                TableName  = TestTableName1,
                SchemaName = schemaName,
                Column     = new ColumnDefinition {
                    Name = TestColumnName1, Type = DbType.DateTime
                }
            };

            context.Expressions.Add(expr);
            var builder = new CreateColumnExpressionBuilder(expr, context);

            builder.SetExistingRowsTo(SystemMethods.CurrentDateTime);
            return(context.Expressions);
        }
        public void CallingWithDefaultSetsDefaultValue()
        {
            var columnMock = new Mock <ColumnDefinition>();

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupProperty(e => e.Column);

            var expression = expressionMock.Object;

            expression.Column = columnMock.Object;

            var contextMock = new Mock <IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.WithDefault(SystemMethods.NewGuid);

            columnMock.VerifySet(c => c.DefaultValue = SystemMethods.NewGuid);
        }
        public void CallingSeededIdentitySetsAdditionalProperties()
        {
            var contextMock = new Mock <IMigrationContext>();

            var columnMock = new Mock <ColumnDefinition>();

            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.Identity(23, 44);

            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(SqlServerExtensions.IdentitySeed, 23));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair <string, object>(SqlServerExtensions.IdentityIncrement, 44));
        }
        public void CallingWithDefaultValueSetsDefaultValue()
        {
            const int value = 42;

            var columnMock = new Mock <ColumnDefinition>();

            var expressionMock = new Mock <CreateColumnExpression>();

            expressionMock.SetupProperty(e => e.Column);

            var expression = expressionMock.Object;

            expression.Column = columnMock.Object;

            var contextMock = new Mock <IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.WithDefaultValue(value);

            columnMock.VerifySet(c => c.DefaultValue = value);
        }
        public void CallingWithDefaultValueSetsDefaultValue()
        {
            const int value = 42;

            var columnMock = new Mock<ColumnDefinition>();
            columnMock.VerifySet(c => c.DefaultValue = value, Times.AtMostOnce());

            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupProperty(e => e.Column);

            var expression = expressionMock.Object;
            expression.Column = columnMock.Object;

            var contextMock = new Mock<IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            builder.WithDefaultValue(value);

            columnMock.VerifyAll();
        }
        public void CallingReferencesAddsNewForeignKeyExpressionToContext()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();
            collectionMock.Verify(x => x.Add(It.Is<CreateForeignKeyExpression>(
                fk => fk.ForeignKey.Name == "fk_foo" &&
                        fk.ForeignKey.ForeignTable == "FooTable" &&
                        fk.ForeignKey.ForeignColumns.Contains("BarColumn") &&
                        fk.ForeignKey.ForeignColumns.Count == 1 &&
                        fk.ForeignKey.PrimaryTable == "Bacon" &&
                        fk.ForeignKey.PrimaryColumns.Contains("BaconId") &&
                        fk.ForeignKey.PrimaryColumns.Count == 1
                                                )), Times.AtMostOnce());

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);
            contextMock.VerifyGet(x => x.Expressions, Times.AtMostOnce());

            var columnMock = new Mock<ColumnDefinition>();
            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupGet(x => x.TableName).Returns("Bacon");
            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.References("fk_foo", "FooTable", new[] { "BarColumn" });

            collectionMock.VerifyAll();
            contextMock.VerifyAll();
            columnMock.VerifyAll();
            expressionMock.VerifyAll();
        }
 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));
 }
        public void CallingOnTableSetsTableName()
        {
            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupSet(x => x.TableName = "Bacon").AtMostOnce();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object);
            builder.OnTable("Bacon");

            expressionMock.VerifyAll();
        }
        public void CallingUniqueNamedAddsIndexExpressionToContext()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var columnMock = new Mock<ColumnDefinition>();
            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupGet(x => x.SchemaName).Returns("Eggs");
            expressionMock.SetupGet(x => x.TableName).Returns("Bacon");
            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            builder.Unique("IX_Bacon_BaconId");

            collectionMock.Verify(x => x.Add(It.Is<CreateIndexExpression>(
                ix => ix.Index.Name == "IX_Bacon_BaconId"
                      && ix.Index.TableName == "Bacon"
                      && ix.Index.SchemaName == "Eggs"
                      && ix.Index.IsUnique
                      && !ix.Index.IsClustered
                      && ix.Index.Columns.All(c => c.Name == "BaconId")
                                                 )));

            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingWithDefaultSetsDefaultValue()
        {
            var columnMock = new Mock<ColumnDefinition>();

            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupProperty(e => e.Column);

            var expression = expressionMock.Object;
            expression.Column = columnMock.Object;

            var contextMock = new Mock<IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            builder.WithDefault(SystemMethods.NewGuid);

            columnMock.VerifySet(c => c.DefaultValue = SystemMethods.NewGuid);
        }
        public void CallingSeededIdentitySetsAdditionalProperties() 
        {
            var contextMock = new Mock<IMigrationContext>();

            var columnMock = new Mock<ColumnDefinition>();
            columnMock.SetupGet(x => x.Name).Returns("BaconId");

            var expressionMock = new Mock<CreateColumnExpression>();
            expressionMock.SetupGet(x => x.Column).Returns(columnMock.Object);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            builder.Identity(23, 44);

            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair<string, object>(SqlServerExtensions.IdentitySeed, 23));
            columnMock.Object.AdditionalFeatures.ShouldContain(
                new KeyValuePair<string, object>(SqlServerExtensions.IdentityIncrement, 44));
        }
        public void ColumnHelperSetOnCreation()
        {
            var expressionMock = new Mock<CreateColumnExpression>();
            var contextMock = new Mock<IMigrationContext>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);

            Assert.IsNotNull(builder.ColumnHelper);
        }
        public void IColumnExpressionBuilder_UsesExpressionColumnSchemaAndTableName()
        {
            var expressionMock = new Mock<CreateColumnExpression>();
            var contextMock = new Mock<IMigrationContext>();
            expressionMock.SetupGet(n => n.SchemaName).Returns("Fred");
            expressionMock.SetupGet(n => n.TableName).Returns("Flinstone");

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            var builderAsInterface = (IColumnExpressionBuilder)builder;

            Assert.AreEqual("Fred", builderAsInterface.SchemaName);
            Assert.AreEqual("Flinstone", builderAsInterface.TableName);
        }
        public void IColumnExpressionBuilder_UsesExpressionColumn()
        {
            var expressionMock = new Mock<CreateColumnExpression>();
            var contextMock = new Mock<IMigrationContext>();
            var curColumn = new Mock<ColumnDefinition>().Object;
            expressionMock.SetupGet(n => n.Column).Returns(curColumn);

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            var builderAsInterface = (IColumnExpressionBuilder)builder;

            Assert.AreSame(curColumn, builderAsInterface.Column);
        }
        private void VerifyColumnHelperCall(Action<CreateColumnExpressionBuilder> callToTest, System.Linq.Expressions.Expression<Action<ColumnExpressionBuilderHelper>> expectedHelperAction)
        {
            var expressionMock = new Mock<CreateColumnExpression>();
            var contextMock = new Mock<IMigrationContext>();
            var helperMock = new Mock<ColumnExpressionBuilderHelper>();

            var builder = new CreateColumnExpressionBuilder(expressionMock.Object, contextMock.Object);
            builder.ColumnHelper = helperMock.Object;

            callToTest(builder);

            helperMock.Verify(expectedHelperAction);
        }