public void JoinTableCreated()
        {
            //arrange
            var products = _schema.FindTableByName("CategoryProducts");
            var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEfCore };
            var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer());

            //act
            var result = target.Write();

            //assert
            //        public static void Map(EntityTypeBuilder<CategoryProduct> b)
            //        {
            //            //table
            //            b.ToTable("CategoryProducts");
            //            // Primary key (composite)
            //            b.HasKey(x => new { x.CategoryId, x.ProductId });
            //            // Properties
            //            b.HasOne(x => x.Category).WithOne();
            //            b.HasOne(x => x.Product).WithOne();

            var hasKey =
                result.Contains("b.HasKey(x => new { x.CategoryId, x.ProductId });");
            //we have to create a many to many table for this
            var hasCategory = result.Contains("b.HasOne(x => x.Category).WithOne(");
            var hasProduct = result.Contains("b.HasOne(x => x.Product).WithOne(");

            Assert.IsTrue(hasKey);
            Assert.IsTrue(hasCategory);
            Assert.IsTrue(hasProduct);
        }
        public void ForeignKeyIdTest()
        {
            //arrange
            DatabaseSchema schema = PrepareModel();
            var products = schema.FindTableByName("Products");
            var codeWriterSettings = new CodeWriterSettings
            {
                CodeTarget = CodeTarget.PocoEntityCodeFirst,
                UseForeignKeyIdProperties = true
            };
            var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer());

            //act
            var result = target.Write();

            //assert
            var hasMappingClass = result.Contains("public class ProductMapping : EntityTypeConfiguration<Product>");
            var hasForeignKeyIdProperty =
                result.Contains("Property(x => x.SupplierKeyId).HasColumnName(\"SupplierKey\")");
            var hasForeignKey = result.Contains("HasRequired(x => x.SupplierKey).WithMany(c => c.ProductCollection).HasForeignKey(c => c.SupplierKeyId);");

            Assert.IsTrue(hasMappingClass);
            Assert.IsTrue(hasForeignKeyIdProperty);
            Assert.IsTrue(hasForeignKey);
        }
        public void TestOneToOneTable()
        {
            //arrange
            var schema = Arrange();
            var table = schema.FindTableByName("Products");
            var codeWriterSettings = new CodeWriterSettings {CodeTarget = CodeTarget.PocoEntityCodeFirst};
            var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer());

            //act
            var txt = target.Write();

            //assert
            Assert.IsTrue(txt.Contains("HasOptional(x => x.ProductDetail);"));
        }
        public void TableLinksToJoinTable()
        {
            //arrange
            var products = _schema.FindTableByName("Categories");
            var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEfCore };
            var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer());

            //act
            var result = target.Write();

            //assert
            var hasCategory = result.Contains("b.HasMany(x => x.CategoryProductCollection).WithOne(");

            Assert.IsTrue(hasCategory);
        }
        public void WriteCodeFirstMappingInverseForeignKeyTest()
        {
            //arrange
            var schema = ArrangeSchema();
            var table = schema.FindTableByName("Orders");

            var cw = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());

            //act
            var txt = cw.Write();

            //assert
            var hasBillingAddress = txt.Contains("HasRequired(x => x.BillingAddress).WithMany(c => c.BillingAddressCollection).Map(m => m.MapKey(\"BillingAddress\"));");
            var hasDeliveryAddress = txt.Contains("HasRequired(x => x.DeliveryAddress).WithMany(c => c.DeliveryAddressCollection).Map(m => m.MapKey(\"DeliveryAddress\"));");

            Assert.IsTrue(hasBillingAddress);
            Assert.IsTrue(hasDeliveryAddress);
        }
        public void WriteCodeFirstMappingForeignKeyTest()
        {
            //arrange
            var schema = ArrangeSchema();
            var table = schema.FindTableByName("Address");

            var cw = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());

            //act
            var txt = cw.Write();

            //assert
            var hasBillingAddress = txt.Contains("HasMany(x => x.BillingAddressCollection);");
            var hasDeliveryAddress = txt.Contains("HasMany(x => x.DeliveryAddressCollection);");

            Assert.IsTrue(hasBillingAddress);
            Assert.IsTrue(hasDeliveryAddress);
        }
        public void ExecuteTest()
        {
            //arrange
            DatabaseSchema schema = PrepareModel();
            var products = schema.FindTableByName("Products");
            var target = new CodeFirstMappingWriter(products, new CodeWriterSettings(), new MappingNamer());

            //act
            var result = target.Write();

            //assert
            var hasMappingClass = result.Contains("public class ProductMapping : EntityTypeConfiguration<Product>");
            //we don't have the UseForeignKeyIdProperties=true, so map back to the instance property
            var hasForeignKey = 
                result.Contains("HasRequired(x => x.SupplierKey).WithMany(c => c.ProductCollection).Map(m => m.MapKey(\"SupplierKey\"))");
            var hasManyToMany = result.Contains("HasMany(x => x.CategoryCollection).WithMany(z => z.ProductCollection)");

            Assert.IsTrue(hasMappingClass);
            Assert.IsTrue(hasForeignKey);
            Assert.IsTrue(hasManyToMany);
        }
        public void ExecuteTest()
        {
            //arrange
            DatabaseSchema schema = PrepareModel();
            var products = schema.FindTableByName("Products");
            var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEfCore };
            var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer());

            //act
            var result = target.Write();

            //assert
            var hasMappingClass = result.Contains("public static class ProductMapping");
            //we don't have the UseForeignKeyIdProperties=true, so map back to the instance property

            //EF v6 code
            //            HasRequired(x => x.SupplierKey).WithMany(c => c.ProductCollection).Map(m => m.MapKey("SupplierKey"));
            //            // Navigation properties
            //            // Many to many foreign key to Categories
            //            HasMany(x => x.CategoryCollection).WithMany(z => z.ProductCollection)
            //            .Map(map =>
            //            {
            //                map.ToTable("CategoryProducts");
            //                map.MapLeftKey("ProductId");
            //                map.MapRightKey("CategoryId");
            //            }

            var hasForeignKey =
                result.Contains("b.HasOne(x => x.SupplierKey).WithMany(c => c.ProductCollection);");
            //we have to create a many to many table for this
            //var hasManyToMany = result.Contains("HasMany(x => x.CategoryCollection).WithMany(z => z.ProductCollection)");

            Assert.IsTrue(hasMappingClass);
            Assert.IsTrue(hasForeignKey);
            //Assert.IsTrue(hasManyToMany);
        }
        public void HasMaxLengthTest()
        {
            //arrange
            var schema = new DatabaseSchema(null, null);
            var table = schema.AddTable("Products")
                .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
                .AddColumn("ProductName", DbType.String).AddLength(20)
                .Table;
            //we need datatypes
            schema.DataTypes.Add(new DataType("INT", "System.Int32"));
            schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
            //make sure it's all tied up
            DatabaseSchemaFixer.UpdateReferences(schema);

            var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());

            //act
            var result = target.Write();

            //assert
            var hasMaxLength = result.Contains("Property(x => x.ProductName).HasMaxLength(20)");

            Assert.IsTrue(hasMaxLength);
        }
        public void MappingSharedPrimaryKeyTest()
        {
            //arrange
            var schema = new DatabaseSchema(null, null);
            schema
                .AddTable("vehicle")
                .AddColumn<string>("regnum").AddPrimaryKey().AddLength(25)
                .AddColumn<string>("model").AddLength(32)
                .AddTable("car")
                .AddColumn<string>("regnum").AddLength(25).AddPrimaryKey().AddForeignKey("fk", "vehicle")
                .AddColumn<int>("doors");
            //make sure it's all tied up
            DatabaseSchemaFixer.UpdateReferences(schema);
            //make sure .Net names are assigned
            PrepareSchemaNames.Prepare(schema, new Namer());
            var table = schema.FindTableByName("car");

            var mappingNamer = new MappingNamer();
            var codeWriterSettings = new CodeWriterSettings{ CodeTarget = CodeTarget.PocoEntityCodeFirst };
            var target = new CodeFirstMappingWriter(table, codeWriterSettings, mappingNamer);

            //act
            var txt = target.Write();

            //assert
            var hasScalarKey = txt.Contains("HasKey(x => x.Regnum);");
            var hasForeignKey = txt.Contains("HasRequired(x => x.Vehicle);");

            Assert.IsTrue(hasScalarKey);
            Assert.IsTrue(hasForeignKey);
        }
        public void MappingNameWithConflictsTest()
        {
            //arrange
            var schema = new DatabaseSchema(null, null);
            var table = schema.AddTable("Products")
                .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
                .Table;
            table.NetName = "Product";
            //we need datatypes
            schema.DataTypes.Add(new DataType("INT", "System.Int32"));
            //make sure it's all tied up
            DatabaseSchemaFixer.UpdateReferences(schema);


            var mappingNamer = new MappingNamer();
            var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), mappingNamer);
            //we also have a table called "ProductMapping"
            //so we can't call the mapping class for "Product" the same name
            mappingNamer.EntityNames.Add("ProductMapping");
            mappingNamer.EntityNames.Add("ProductMappingMap");

            //act
            target.Write();
            //now the name is assigned
            var className = target.MappingClassName;

            //assert
            Assert.AreEqual("ProductMappingMapMap", className, "Should not conflict with the existing names");
            Assert.AreEqual(3, mappingNamer.EntityNames.Count, "Should add the name to the list");
        }
        public void MappingNameTest()
        {
            //arrange
            var schema = new DatabaseSchema(null, null);
            var table = schema.AddTable("Products")
                .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
                .Table;
            table.NetName = "Product";
            //we need datatypes
            schema.DataTypes.Add(new DataType("INT", "System.Int32"));
            //make sure it's all tied up
            DatabaseSchemaFixer.UpdateReferences(schema);

            var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());

            //act
            target.Write();
            //now the name is assigned
            var className = target.MappingClassName;

            //assert
            Assert.AreEqual("ProductMapping", className);
        }
        public void IsImageTest()
        {
            //arrange
            var schema = new DatabaseSchema(null, null);
            var table = schema.AddTable("Products")
                .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
                .AddColumn("Picture", "image")
                .Table;
            //we need datatypes
            schema.DataTypes.Add(new DataType("INT", "System.Int32"));
            schema.DataTypes.Add(new DataType("image", "System.Byte[]"));
            //make sure it's all tied up
            DatabaseSchemaFixer.UpdateReferences(schema);

            var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());

            //act
            var result = target.Write();

            //assert
            //EF CF will default to varbinary so we must specify
            var hasImageType = result.Contains("Property(x => x.Picture).HasColumnType(\"image\")");

            Assert.IsTrue(hasImageType);
        }
예제 #14
0
        private void WriteMapping(DatabaseTable table, ProjectWriter pw)
        {
            string fileName;
            switch (_codeWriterSettings.CodeTarget)
            {
                case CodeTarget.PocoNHibernateFluent:
                    fileName = WriteFluentMapping(table);
                    pw.AddClass(@"Mapping\" + fileName);
                    break;
                case CodeTarget.PocoNHibernateHbm:
                    //TPT subclasses are mapped in base class
                    if (table.FindInheritanceTable() != null) return;
                    var mw = new MappingWriter(table, _codeWriterSettings);
                    var txt = mw.Write();

                    fileName = table.NetName + ".hbm.xml";
                    var path = Path.Combine(_mappingPath, fileName);
                    File.WriteAllText(path, txt);
                    pw.AddMap(@"mapping\" + fileName);
                    break;
                case CodeTarget.PocoEntityCodeFirst:
                case CodeTarget.PocoRiaServices:
                    case CodeTarget.PocoEfCore:
                    var cfmw = new CodeFirstMappingWriter(table, _codeWriterSettings, _mappingNamer);
                    var cfmap = cfmw.Write();

                    fileName = cfmw.MappingClassName + ".cs";

                    var filePath = Path.Combine(_mappingPath, fileName);
                    File.WriteAllText(filePath, cfmap);
                    pw.AddClass(@"Mapping\" + fileName);
                    break;
            }
        }