public virtual IModel CreateModel(Action<ModelBuilder> onModelCreating)
{
Check.NotNull(onModelCreating, nameof(onModelCreating));
var model = new Model();
var conventions = new ConventionSet();
var modelBuilder = new ModelBuilder(conventions, model);
onModelCreating(modelBuilder);
return model;
}
public void Can_create_a_model_builder_with_given_conventions_only()
{
var convention = new TestConvention();
var conventions = new ConventionSet();
conventions.EntityTypeAddedConventions.Add(convention);
var modelBuilder = new ModelBuilder(conventions);
modelBuilder.Entity<Random>();
Assert.True(convention.Applied);
Assert.NotNull(modelBuilder.Model.GetEntityType(typeof(Random)));
}
protected virtual ConventionSet CreateConventionSet()
{
var conventions = new ConventionSet();
conventions.EntityTypeAddedConventions.Add(new PropertyDiscoveryConvention());
conventions.EntityTypeAddedConventions.Add(new KeyDiscoveryConvention());
conventions.EntityTypeAddedConventions.Add(new RelationshipDiscoveryConvention());
var keyConvention = new KeyConvention();
conventions.KeyAddedConventions.Add(keyConvention);
conventions.ForeignKeyAddedConventions.Add(new ForeignKeyPropertyDiscoveryConvention());
conventions.ForeignKeyRemovedConventions.Add(keyConvention);
return conventions;
}
public void OnPropertyAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalPropertyBuilder propertyBuilder = null;
var convention = new Mock<IPropertyConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.NotNull(b);
propertyBuilder = new InternalPropertyBuilder(b.Metadata, b.ModelBuilder, ConfigurationSource.Convention);
return propertyBuilder;
});
conventions.PropertyAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IPropertyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.Same(propertyBuilder, b);
return null;
});
conventions.PropertyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IPropertyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.PropertyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var explicitKeyBuilder = entityBuilder.Property(typeof(int), "OrderId", ConfigurationSource.Convention);
Assert.Null(explicitKeyBuilder);
Assert.NotNull(propertyBuilder);
}
public void OnEntityTypeAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalEntityTypeBuilder entityTypeBuilder = null;
var convention = new Mock<IEntityTypeConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.NotNull(b);
entityTypeBuilder = new InternalEntityTypeBuilder(b.Metadata, b.ModelBuilder);
return entityTypeBuilder;
});
conventions.EntityTypeAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IEntityTypeConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.Same(entityTypeBuilder, b);
return null;
});
conventions.EntityTypeAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IEntityTypeConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.EntityTypeAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
Assert.Null(builder.Entity(typeof(Order), ConfigurationSource.Convention));
Assert.NotNull(entityTypeBuilder);
}
public ConventionDispatcher([NotNull] ConventionSet conventionSet)
{
Check.NotNull(conventionSet, nameof(conventionSet));
_conventionSet = conventionSet;
}
private static InternalModelBuilder CreateInternalModelBuilder()
{
var conventions = new ConventionSet();
conventions.EntityTypeAddedConventions.Add(new PropertyDiscoveryConvention());
conventions.EntityTypeAddedConventions.Add(new KeyDiscoveryConvention());
var keyConvention = new KeyConvention();
conventions.KeyAddedConventions.Add(keyConvention);
conventions.ForeignKeyRemovedConventions.Add(keyConvention);
return new InternalModelBuilder(new Model(), conventions);
}
public void OnForeignKeyAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalRelationshipBuilder relationsipBuilder = null;
var convention = new Mock<IForeignKeyConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b =>
{
Assert.NotNull(b);
relationsipBuilder = new InternalRelationshipBuilder(b.Metadata, b.ModelBuilder, null);
return relationsipBuilder;
});
conventions.ForeignKeyAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IForeignKeyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b =>
{
Assert.Same(relationsipBuilder, b);
return null;
});
conventions.ForeignKeyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IForeignKeyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.ForeignKeyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
entityBuilder.PrimaryKey(new[] { "OrderId" }, ConfigurationSource.Convention);
Assert.Null(entityBuilder.Relationship(typeof(Order), typeof(Order), null, null, ConfigurationSource.Convention));
Assert.NotNull(relationsipBuilder);
}
public void InitializingModel_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
var nullConventionCalled = false;
InternalModelBuilder modelBuilder = null;
var convention = new Mock<IModelConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalModelBuilder>())).Returns<InternalModelBuilder>(b =>
{
Assert.NotNull(b);
modelBuilder = new InternalModelBuilder(b.Metadata, new ConventionSet());
return b;
});
conventions.ModelConventions.Add(convention.Object);
var nullConvention = new Mock<IModelConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalModelBuilder>())).Returns<InternalModelBuilder>(b =>
{
nullConventionCalled = true;
return null;
});
conventions.ModelConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IModelConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalModelBuilder>())).Returns<InternalModelBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.ModelConventions.Add(extraConvention.Object);
var builder = new ModelBuilder(conventions);
Assert.NotNull(builder);
Assert.True(nullConventionCalled);
Assert.NotNull(modelBuilder);
}
public void OnForeignKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
var foreignKeyRemoved = false;
var convention = new Mock<IForeignKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>(), It.IsAny<ForeignKey>())).Callback(() => foreignKeyRemoved = true);
conventions.ForeignKeyRemovedConventions.Add(convention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var foreignKey = new ForeignKey(
new[] { entityBuilder.Property(typeof(int), "FK", ConfigurationSource.Convention).Metadata },
entityBuilder.Key(new[] { entityBuilder.Property(typeof(int), "OrderId", ConfigurationSource.Convention).Metadata }, ConfigurationSource.Convention).Metadata);
var conventionDispatcher = new ConventionDispatcher(conventions);
conventionDispatcher.OnForeignKeyRemoved(entityBuilder, foreignKey);
Assert.True(foreignKeyRemoved);
}
public ConventionDispatcher([NotNull] ConventionSet conventionSet)
{
Check.NotNull(conventionSet, nameof(conventionSet));
_conventionSet = conventionSet;
}