public override void Detects_duplicate_columns_in_derived_types_with_different_types()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().Property(c => c.Type);
modelBuilder.Entity <Dog>().Property(c => c.Type);
VerifyError(RelationalStrings.DuplicateColumnNameDataTypeMismatch(
typeof(Cat).Name, "Type", typeof(Dog).Name, "Type", "Type", nameof(Animal), "nvarchar(max)", "int"), modelBuilder.Model);
}
public virtual void Detects_duplicate_columns_in_derived_types_with_different_types()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().Property(c => c.Type);
modelBuilder.Entity <Dog>().Property(c => c.Type);
VerifyError(RelationalStrings.DuplicateColumnNameDataTypeMismatch(
nameof(Cat), nameof(Cat.Type), nameof(Dog), nameof(Dog.Type), nameof(Cat.Type), nameof(Animal), "just_string(2000)", "default_int_mapping"), modelBuilder.Model);
}
public virtual void Detects_duplicate_column_names_within_hierarchy_with_different_nullability()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>();
modelBuilder.Entity <Dog>().Property(d => d.Type).HasColumnName("Id");
VerifyError(RelationalStrings.DuplicateColumnNameNullabilityMismatch(
nameof(Animal), nameof(Animal.Id), nameof(Dog), nameof(Dog.Type), nameof(Animal.Id), nameof(Animal)), modelBuilder.Model);
}
public virtual void Detects_duplicate_column_names_within_hierarchy_with_different_unicode()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().Ignore(e => e.Type).Property(c => c.Breed).IsUnicode(false);
modelBuilder.Entity <Dog>().Ignore(e => e.Type).Property(d => d.Breed).IsUnicode();
VerifyError(RelationalStrings.DuplicateColumnNameDataTypeMismatch(
nameof(Cat), nameof(Cat.Breed), nameof(Dog), nameof(Dog.Breed), nameof(Cat.Breed), nameof(Animal), "varchar(max)", "nvarchar(max)"), modelBuilder.Model);
}
public virtual void Detects_duplicate_column_names_within_hierarchy_with_different_DefaultValueSql()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().Property(c => c.Breed).HasDefaultValueSql("1");
modelBuilder.Entity <Dog>();
VerifyError(RelationalStrings.DuplicateColumnNameDefaultSqlMismatch(
nameof(Cat), nameof(Cat.Breed), nameof(Dog), nameof(Dog.Breed), nameof(Cat.Breed), nameof(Animal), "1", ""), modelBuilder.Model);
}
public virtual void Detects_duplicate_column_names_within_hierarchy_with_different_MaxLength()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().Property(c => c.Breed).HasMaxLength(30);
modelBuilder.Entity <Dog>().Property(d => d.Breed).HasMaxLength(15);
VerifyError(RelationalStrings.DuplicateColumnNameDataTypeMismatch(
nameof(Cat), nameof(Cat.Breed), nameof(Dog), nameof(Dog.Breed), nameof(Cat.Breed), nameof(Animal), "just_string(30)", "just_string(15)"), modelBuilder.Model);
}
public override void Detects_duplicate_column_names()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>().Property(b => b.Id).HasColumnName("Name");
VerifyError(
RelationalStrings.DuplicateColumnNameDataTypeMismatch(
nameof(Animal), nameof(Animal.Id),
nameof(Animal), nameof(Animal.Name), "Name", nameof(Animal), "int", "nvarchar(max)"),
modelBuilder.Model);
}
public virtual void Passes_for_incompatible_indexes_within_hierarchy_when_one_name_configured_explicitly()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
var index1 = modelBuilder.Entity <Cat>().HasIndex(c => c.Name).IsUnique().HasName("IX_Animal_Name").Metadata;
var index2 = modelBuilder.Entity <Dog>().HasIndex(d => d.Name).IsUnique(false).Metadata;
Validate(modelBuilder.Model);
Assert.Equal("IX_Animal_Name", index1.Relational().Name);
Assert.Equal("IX_Animal_Name0", index2.Relational().Name);
}
public virtual void Detects_missing_non_string_discriminator_values()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <C>();
modelBuilder.Entity <A>().HasDiscriminator <byte>("ClassType")
.HasValue <A>(0)
.HasValue <D>(1);
var model = modelBuilder.Model;
VerifyError(RelationalStrings.NoDiscriminatorValue(typeof(C).Name), model);
}
public virtual void Passes_for_compatible_duplicate_index_names_within_hierarchy()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
var index1 = modelBuilder.Entity <Cat>().HasIndex(c => c.Breed).Metadata;
var index2 = modelBuilder.Entity <Dog>().HasIndex(c => c.Breed).Metadata;
Validate(modelBuilder.Model);
Assert.NotSame(index1, index2);
Assert.Equal(index1.Relational().Name, index2.Relational().Name);
}
public virtual void Detects_duplicate_discriminator_values()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <A>().HasDiscriminator <byte>("ClassType")
.HasValue <A>(1)
.HasValue <C>(1)
.HasValue <D>(2);
var model = modelBuilder.Model;
VerifyError(RelationalStrings.DuplicateDiscriminatorValue(typeof(C).Name, 1, typeof(A).Name), model);
}
public virtual void Does_not_detect_missing_discriminator_value_for_abstract_class()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Abstract>();
modelBuilder.Entity <A>().HasDiscriminator <byte>("ClassType")
.HasValue <A>(0)
.HasValue <C>(1)
.HasValue <D>(2)
.HasValue <Generic <string> >(3);
Validate(modelBuilder.Model);
}
public virtual void Detects_duplicate_index_names_within_hierarchy_with_different_uniqueness()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().HasIndex(c => c.Name).IsUnique();
modelBuilder.Entity <Dog>().HasIndex(d => d.Name).IsUnique(false);
VerifyError(RelationalStrings.DuplicateIndexUniquenessMismatch(
"{'" + nameof(Dog.Name) + "'}", nameof(Dog),
"{'" + nameof(Cat.Name) + "'}", nameof(Cat),
nameof(Animal), "IX_Animal_Name"),
modelBuilder.Model);
}
public virtual void Detects_duplicate_foreignKey_names_within_hierarchy_with_different_uniqueness()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().HasOne <Person>().WithMany().HasForeignKey(c => c.Name).HasPrincipalKey(p => p.Name);
modelBuilder.Entity <Dog>().HasOne <Person>().WithOne().HasForeignKey <Dog>(d => d.Name).HasPrincipalKey <Person>(p => p.Name);
VerifyError(RelationalStrings.DuplicateForeignKeyUniquenessMismatch(
"{'" + nameof(Dog.Name) + "'}", nameof(Dog),
"{'" + nameof(Cat.Name) + "'}", nameof(Cat),
nameof(Animal), "FK_Animal_Person_Name"),
modelBuilder.Model);
}
public virtual void Passes_for_incompatible_foreignKeys_within_hierarchy_when_one_name_configured_explicitly()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
var fk1 = modelBuilder.Entity <Cat>().HasOne <Person>().WithMany().HasForeignKey(c => c.Name).HasPrincipalKey(p => p.Name)
.OnDelete(DeleteBehavior.Cascade).HasConstraintName("FK_Animal_Person_Name").Metadata;
var fk2 = modelBuilder.Entity <Dog>().HasOne <Person>().WithMany().HasForeignKey(d => d.Name).HasPrincipalKey(p => p.Name)
.OnDelete(DeleteBehavior.SetNull).Metadata;
Validate(modelBuilder.Model);
Assert.Equal("FK_Animal_Person_Name", fk1.Relational().Name);
Assert.Equal("FK_Animal_Person_Name0", fk2.Relational().Name);
}
public virtual void Detects_duplicate_index_names_within_hierarchy_with_different_column_order()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().HasIndex(c => new { c.Name, c.Breed }).HasName("IX");
modelBuilder.Entity <Dog>().HasIndex(d => new { d.Breed, d.Name }).HasName("IX");
VerifyError(RelationalStrings.DuplicateIndexColumnMismatch(
"{'" + nameof(Dog.Breed) + "', '" + nameof(Dog.Name) + "'}", nameof(Dog),
"{'" + nameof(Cat.Name) + "', '" + nameof(Cat.Breed) + "'}", nameof(Cat),
nameof(Animal), "IX",
"{'" + nameof(Dog.Breed) + "', '" + nameof(Dog.Name) + "'}",
"{'" + nameof(Cat.Name) + "', '" + nameof(Cat.Breed) + "'}"),
modelBuilder.Model);
}
public virtual void Detects_duplicate_index_names_within_hierarchy_with_different_column_count()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>().Property <int>("Shadow");
modelBuilder.Entity <Cat>().HasIndex(nameof(Cat.Name), "Shadow").HasName("IX");
modelBuilder.Entity <Dog>().HasIndex(d => d.Name).HasName("IX");
VerifyError(RelationalStrings.DuplicateIndexColumnMismatch(
"{'" + nameof(Dog.Name) + "'}", nameof(Dog),
"{'" + nameof(Cat.Name) + "', 'Shadow'}", nameof(Cat),
nameof(Animal), "IX",
"{'" + nameof(Dog.Name) + "'}",
"{'" + nameof(Cat.Name) + "', 'Shadow'}"),
modelBuilder.Model);
}
public void Detects_function_with_invalid_return_type_throws()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
var methodInfo
= typeof(DbFunctionMetadataTests.TestMethods)
.GetRuntimeMethod(nameof(DbFunctionMetadataTests.TestMethods.MethodD), new Type[] { });
modelBuilder.HasDbFunction(methodInfo);
VerifyError(
RelationalStrings.DbFunctionInvalidReturnType(
methodInfo.DisplayName(),
typeof(DbFunctionMetadataTests.TestMethods).ShortDisplayName()),
modelBuilder.Model);
}
public virtual void Detects_duplicate_foreignKey_names_within_hierarchy_with_different_column_order()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().HasOne <Person>().WithMany().HasForeignKey(c => new { c.Name, c.Breed }).HasPrincipalKey(p => new { p.Name, p.FavoriteBreed }).HasConstraintName("FK");
modelBuilder.Entity <Dog>().HasOne <Person>().WithMany().HasForeignKey(d => new { d.Breed, d.Name }).HasPrincipalKey(p => new { p.FavoriteBreed, p.Name }).HasConstraintName("FK");
VerifyError(RelationalStrings.DuplicateForeignKeyColumnMismatch(
"{'" + nameof(Dog.Breed) + "', '" + nameof(Dog.Name) + "'}", nameof(Dog),
"{'" + nameof(Cat.Name) + "', '" + nameof(Cat.Breed) + "'}", nameof(Cat),
nameof(Animal), "FK",
"{'" + nameof(Dog.Breed) + "', '" + nameof(Dog.Name) + "'}",
"{'" + nameof(Cat.Name) + "', '" + nameof(Cat.Breed) + "'}"),
modelBuilder.Model);
}
public virtual void Detects_function_with_invalid_parameter_type_but_translate_callback_does_not_throw()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
var methodInfo
= typeof(DbFunctionMetadataTests.TestMethods)
.GetRuntimeMethod(
nameof(DbFunctionMetadataTests.TestMethods.MethodF),
new[] { typeof(DbFunctionMetadataTests.MyBaseContext) });
var dbFuncBuilder = modelBuilder.HasDbFunction(methodInfo);
dbFuncBuilder.HasTranslation(parameters => null);
Validate(modelBuilder.Model);
}
public virtual void Detects_duplicate_foreignKey_names_within_hierarchy_with_different_principal_tables()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>().HasOne <Person>().WithMany().HasForeignKey("FriendId").HasConstraintName("FK");
modelBuilder.Entity <Dog>().HasOne <Animal>().WithMany().HasForeignKey("FriendId").HasConstraintName("FK");
VerifyError(RelationalStrings.DuplicateForeignKeyPrincipalTableMismatch(
"{'FriendId'}", nameof(Dog),
"{'FriendId'}", nameof(Cat),
nameof(Animal), "FK",
nameof(Animal),
nameof(Person)),
modelBuilder.Model);
}
public virtual void Detects_duplicate_foreignKey_names_within_hierarchy_with_different_column_count()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>().Property <int>("FriendId");
modelBuilder.Entity <Animal>().Property <string>("Shadow");
modelBuilder.Entity <Cat>().HasOne <Person>().WithMany().HasForeignKey("FriendId", "Shadow").HasPrincipalKey(p => new { p.Id, p.Name }).HasConstraintName("FK");
modelBuilder.Entity <Dog>().HasOne <Person>().WithMany().HasForeignKey("FriendId").HasConstraintName("FK");
VerifyError(RelationalStrings.DuplicateForeignKeyColumnMismatch(
"{'FriendId'}", nameof(Dog),
"{'FriendId', 'Shadow'}", nameof(Cat),
nameof(Animal), "FK",
"{'FriendId'}",
"{'FriendId', 'Shadow'}"),
modelBuilder.Model);
}
public virtual void Detects_function_with_invalid_parameter_type_but_no_translate_callback_throws()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
var methodInfo
= typeof(DbFunctionMetadataTests.TestMethods)
.GetRuntimeMethod(
nameof(DbFunctionMetadataTests.TestMethods.MethodF),
new[] { typeof(DbFunctionMetadataTests.MyBaseContext) });
modelBuilder.HasDbFunction(methodInfo);
VerifyError(
RelationalStrings.DbFunctionInvalidParameterType(
"context", methodInfo.DisplayName(), typeof(DbFunctionMetadataTests.MyBaseContext).ShortDisplayName()),
modelBuilder.Model);
}
private void Compare_returns_0_only_for_entries_that_have_same_key_values_generic <T>(T value1, T value2)
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
var model = modelBuilder.Model;
var entityType = model.AddEntityType(typeof(object));
var keyProperty = entityType.AddProperty("Id", typeof(T));
keyProperty.IsNullable = false;
entityType.SetPrimaryKey(keyProperty);
var optionsBuilder = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseModel(RelationalTestHelpers.Instance.Finalize(modelBuilder))
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var stateManager = new DbContext(optionsBuilder.Options).GetService <IStateManager>();
var entry1 = stateManager.GetOrCreateEntry(new object());
entry1[(IProperty)keyProperty] = value1;
entry1.SetEntityState(EntityState.Modified);
var modificationCommand1 = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommand1.AddEntry(entry1, true);
var entry2 = stateManager.GetOrCreateEntry(new object());
entry2[(IProperty)keyProperty] = value2;
entry2.SetEntityState(EntityState.Modified);
var modificationCommand2 = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommand2.AddEntry(entry2, true);
var modificationCommand3 = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommand3.AddEntry(entry1, true);
var mCC = new ModificationCommandComparer();
Assert.True(0 > mCC.Compare(modificationCommand1, modificationCommand2));
Assert.True(0 < mCC.Compare(modificationCommand2, modificationCommand1));
Assert.True(0 == mCC.Compare(modificationCommand1, modificationCommand3));
}
public virtual void Detects_duplicate_column_names_within_hierarchy_with_different_value_generation_strategy()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>(cb =>
{
cb.Property(c => c.Identity).UseSqlServerIdentityColumn();
cb.Property(c => c.Identity).HasColumnName(nameof(Cat.Identity));
});
modelBuilder.Entity <Dog>(db =>
{
db.Property(d => d.Identity).ValueGeneratedNever();
db.Property(c => c.Identity).HasColumnName(nameof(Dog.Identity));
});
VerifyError(
SqlServerStrings.DuplicateColumnNameValueGenerationStrategyMismatch(
nameof(Cat), nameof(Cat.Identity), nameof(Dog), nameof(Dog.Identity), nameof(Cat.Identity), nameof(Animal)), modelBuilder.Model);
}
public virtual void Passes_for_compatible_duplicate_foreignKey_names_within_hierarchy()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
var fk1 = modelBuilder.Entity <Cat>()
.HasOne <Person>()
.WithMany()
.HasForeignKey(c => new { c.Name, c.Breed })
.HasPrincipalKey(p => new { p.Name, p.FavoriteBreed })
.Metadata;
var fk2 = modelBuilder.Entity <Dog>()
.HasOne <Customer>()
.WithMany()
.HasForeignKey(c => new { c.Name, c.Breed })
.HasPrincipalKey(p => new { p.Name, p.FavoriteBreed })
.Metadata;
Validate(modelBuilder.Model);
Assert.NotSame(fk1, fk2);
Assert.Equal(fk1.Relational().Name, fk2.Relational().Name);
}
public virtual void Passes_for_compatible_duplicate_column_names_within_hierarchy()
{
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity <Animal>();
modelBuilder.Entity <Cat>(eb =>
{
eb.Ignore(e => e.Type);
eb.Property(c => c.Breed).HasMaxLength(25);
eb.Property(c => c.Breed).HasColumnName("BreedName");
eb.Property(c => c.Breed).HasDefaultValue("None");
eb.Property <bool>("Selected").HasDefaultValue(false);
});
modelBuilder.Entity <Dog>(eb =>
{
eb.Ignore(e => e.Type);
eb.Property(c => c.Breed).HasMaxLength(25);
eb.Property(c => c.Breed).HasColumnName("BreedName");
eb.Property(c => c.Breed).HasDefaultValue("None");
eb.Property <bool>("Selected").HasDefaultValue(false);
});
Validate(modelBuilder.Model);
}
public void Compare_returns_0_only_for_commands_that_are_equal()
{
IMutableModel model = new Model(TestRelationalConventionSetBuilder.Build());
var entityType = model.AddEntityType(typeof(object));
var key = entityType.AddProperty("Id", typeof(int));
entityType.SetPrimaryKey(key);
var optionsBuilder = new DbContextOptionsBuilder()
.UseModel(model.FinalizeModel())
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider);
var stateManager = new DbContext(optionsBuilder.Options).GetService <IStateManager>();
var entry1 = stateManager.GetOrCreateEntry(new object());
entry1[key] = 1;
entry1.SetEntityState(EntityState.Added);
var modificationCommandAdded = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommandAdded.AddEntry(entry1);
var entry2 = stateManager.GetOrCreateEntry(new object());
entry2[key] = 2;
entry2.SetEntityState(EntityState.Modified);
var modificationCommandModified = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommandModified.AddEntry(entry2);
var entry3 = stateManager.GetOrCreateEntry(new object());
entry3[key] = 3;
entry3.SetEntityState(EntityState.Deleted);
var modificationCommandDeleted = new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null);
modificationCommandDeleted.AddEntry(entry3);
var mCC = new ModificationCommandComparer();
Assert.True(0 == mCC.Compare(modificationCommandAdded, modificationCommandAdded));
Assert.True(0 == mCC.Compare(null, null));
Assert.True(
0 == mCC.Compare(
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(0 > mCC.Compare(null, new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(0 < mCC.Compare(new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null), null));
Assert.True(
0 > mCC.Compare(
new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(
0 < mCC.Compare(
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(
0 > mCC.Compare(
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", "foo", new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(
0 < mCC.Compare(
new ModificationCommand("A", "foo", new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", "dbo", new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(
0 > mCC.Compare(
new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("B", null, new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(
0 < mCC.Compare(
new ModificationCommand("B", null, new ParameterNameGenerator().GenerateNext, false, null),
new ModificationCommand("A", null, new ParameterNameGenerator().GenerateNext, false, null)));
Assert.True(0 > mCC.Compare(modificationCommandModified, modificationCommandAdded));
Assert.True(0 < mCC.Compare(modificationCommandAdded, modificationCommandModified));
Assert.True(0 > mCC.Compare(modificationCommandDeleted, modificationCommandAdded));
Assert.True(0 < mCC.Compare(modificationCommandAdded, modificationCommandDeleted));
Assert.True(0 > mCC.Compare(modificationCommandDeleted, modificationCommandModified));
Assert.True(0 < mCC.Compare(modificationCommandModified, modificationCommandDeleted));
}
protected virtual ConventionSet CreateConventionSet() => TestRelationalConventionSetBuilder.Build();
public void WriteCode_works()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(TestRelationalConventionSetBuilder.Build());
modelBuilder.Entity("TestEntity").Property <int>("Id").HasAnnotation(ScaffoldingAnnotationNames.ColumnOrdinal, 0);
var result = generator.WriteCode(
modelBuilder.Model,
"TestNamespace",
"TestContext",
"Data Source=Test",
dataAnnotations: true);
Assert.Equal("TestContext.cs", result.ContextFile.Path);
Assert.Equal(
@"using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
namespace TestNamespace
{
public partial class TestContext : DbContext
{
public virtual DbSet<TestEntity> { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!optionsBuilder.IsConfigured)
{
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
optionsBuilder.UseTestProvider(""Data Source=Test"");
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{}
}
}
",
result.ContextFile.Code,
ignoreLineEndingDifferences: true);
Assert.Equal(1, result.EntityTypeFiles.Count);
Assert.Equal("TestEntity.cs", result.EntityTypeFiles[0].Path);
Assert.Equal(
@"using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace TestNamespace
{
[Table(""TestEntity"")]
public partial class TestEntity
{
public int Id { get; set; }
}
}
",
result.EntityTypeFiles[0].Code,
ignoreLineEndingDifferences: true);
}
