Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/entityframework/test/EntityFramework/DropAllDatabases.sql

@@ -0,0 +1,24 @@
+-- Generates a SQL script that will drop all databases (except system ones) on the current server.
+
+DECLARE @name nvarchar(255)
+
+DECLARE db CURSOR FOR 
+SELECT Name FROM sysdatabases
+WHERE Name NOT IN ('master', 'tempdb', 'model', 'msdb')
+
+OPEN db;
+
+FETCH NEXT FROM db 
+INTO @name;
+
+WHILE @@FETCH_STATUS = 0
+BEGIN
+    PRINT 'DROP DATABASE "' + @name + '"'
+    PRINT 'GO'
+    
+    FETCH NEXT FROM db 
+    INTO @name
+
+END
+CLOSE db;
+DEALLOCATE db;

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/! DON'T ADD TESTS HERE/ReadMe.txt

@@ -0,0 +1,2 @@
+This project is being used to quarantine files that depend on EntityFramework's InternalsVisibleTo attribute.
+New tests should be added to the FunctionalTests project.

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/App.config

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<configuration>
+    <configSections>
+        <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
+    </configSections>
+    <system.data>
+        <DbProviderFactories>
+            <remove invariant="System.Data.SqlServerCe.4.0"></remove>
+            <add name="Microsoft SQL Server Compact Data Provider" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91" />
+        </DbProviderFactories>
+    </system.data>
+    <connectionStrings>
+        <add name="Scenario_Use_AppConfig_connection_string" providerName="System.Data.SqlClient" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Database=Scenario_Use_AppConfig;" />
+        <add name="Scenario_Use_AppConfig_LocalDb_connection_string" providerName="System.Data.SqlClient" connectionString="Data Source=(localdb)\v11.0;Integrated Security=True;Database=Scenario_Use_AppConfig_LocalDb;" />
+        <add name="Scenario_Use_SqlCe_AppConfig_connection_string" providerName="System.Data.SqlServerCe.4.0" connectionString="Data Source=Scenario_Use_AppConfig.sdf" />
+        <add name="SimpleModelInAppConfig" providerName="System.Data.SqlClient" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Database=SimpleModel.SimpleModel;" />
+        <add name="AllTypeKeysModel.AllTypeKeysContext" providerName="System.Data.SqlClient" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Database=AllTypeKeysDb;" />
+        <add name="SimpleModel.LiveWriterContext" providerName="System.Data.SqlServerCe.4.0" connectionString="Data Source=LiveWriterDb.sdf" />
+        <add name="SimpleModelWithNoDataFromAppConfig" providerName="System.Data.SqlClient" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Database=SimpleModel.SimpleModelWithNoData;" />
+        <add name="InvalidKeywordConnectionString" providerName="System.Data.SqlClient" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Databas=SomethingThatDoesntExist;" />
+        <add name="InvalidProviderNameConnectionString" providerName="System.Data" connectionString="Server=.\SQLEXPRESS;Integrated Security=True;Database=SomethingThatDoesntExist;" />
+        <add name="EntityConnectionForSimpleModel" connectionString="metadata=.\SimpleModel.csdl|.\SimpleModel.ssdl|.\SimpleModel.msl;provider=System.Data.SqlClient;provider connection string=&quot;Server=.\SQLEXPRESS;Integrated Security=True;Database=SimpleModel.SimpleModelContext;&quot;" providerName="System.Data.EntityClient" />
+        <add name="MonsterModel" connectionString="metadata=.\MonsterModel.csdl|.\MonsterModel.ssdl|.\MonsterModel.msl;provider=System.Data.SqlClient;provider connection string=&quot;Server=.\SQLEXPRESS;Integrated Security=True;Database=MonsterModel;&quot;" providerName="System.Data.EntityClient" />
+        <add name="AdvancedPatternsModelFirstContext" connectionString="metadata=.\AdvancedPatterns.csdl|.\AdvancedPatterns.ssdl|.\AdvancedPatterns.msl;provider=System.Data.SqlClient;provider connection string=&quot;Server=.\SQLEXPRESS;Integrated Security=True;Database=AdvancedPatternsModelFirst;&quot;" providerName="System.Data.EntityClient" />
+    </connectionStrings>
+    <appSettings>
+      <add key="DatabaseInitializerForType SimpleModel.SimpleModelContext, EntityFramework.FunctionalTests.Transitional" value="SimpleModel.SimpleModelInitializer, EntityFramework.FunctionalTests.Transitional" />
+      <add key="DatabaseInitializerForType AdvancedPatternsModel.AdvancedPatternsMasterContext, EntityFramework.FunctionalTests.Transitional" value="AdvancedPatternsModel.AdvancedPatternsInitializer, EntityFramework.FunctionalTests.Transitional" />
+      <add key="DatabaseInitializerForType FunctionalTests.ProductivityApi.TemplateModels.CsAdvancedPatterns.AdvancedPatternsModelFirstContext, EntityFramework.FunctionalTests.Transitional" value="FunctionalTests.ProductivityApi.TemplateModels.CsAdvancedPatterns.AdvancedPatternsModelFirstInitializer, EntityFramework.FunctionalTests.Transitional" />
+      <add key="BaseConnectionString" value="Data Source=.\SQLEXPRESS; Integrated Security=True;" />
+    </appSettings>
+    <entityFramework>
+        <defaultConnectionFactory type="System.Data.Entity.TestHelpers.DefaultFunctionalTestsConnectionFactory, EntityFramework.FunctionalTests.Transitional" />
+        <contexts>
+            <context type="FunctionalTests.SimpleMigrationsModel.MigrateInitializerContext, EntityFramework.FunctionalTests.Transitional">
+                <databaseInitializer type="System.Data.Entity.MigrateDatabaseToLatestVersion`2[[FunctionalTests.SimpleMigrationsModel.MigrateInitializerContext, EntityFramework.FunctionalTests.Transitional], [FunctionalTests.SimpleMigrationsModel.MigrateInitializerConfiguration, EntityFramework.FunctionalTests.Transitional]], EntityFramework" />
+            </context>
+        </contexts>
+    </entityFramework>
+    <runtime>
+        <ThrowUnobservedTaskExceptions enabled="true" />
+    </runtime>
+</configuration>

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/AssociationScenarioTests.cs.REMOVED.git-id

@@ -0,0 +1 @@
+e784bf5901f1150da3c550ef1a1538742708b5d2

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/BasicMappingScenarioTests.cs.REMOVED.git-id

@@ -0,0 +1 @@
+1161abca992f1aae517c8e437aef35ba01d7fb20

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/ConfigurationScenarioTests.cs

@@ -0,0 +1,348 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+namespace FunctionalTests
+{
+    using System;
+    using System.ComponentModel.DataAnnotations;
+    using System.ComponentModel.DataAnnotations.Schema;
+    using System.Data.Entity;
+    using System.Data.Entity.Infrastructure;
+    using System.Data.Entity.ModelConfiguration;
+    using System.Linq;
+    using FunctionalTests.Model;
+    using Xunit;
+
+    public class ConfigurationScenarioTests : TestBase
+    {
+        [Fact]
+        public void Can_set_store_type_with_column_annotation_on_base_property()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<BaseEntity_155894>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<BaseEntity_155894>(e => e.Property1).DbEqual("timestamp", c => c.TypeName);
+        }
+
+        public void TestCompositeKeyOrder(
+            Action<DbModelBuilder> configure, string[] expectedPropertyOrder,
+            string[] expectedColumnOrder)
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            configure(modelBuilder);
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+
+            Assert.True(
+                expectedPropertyOrder.SequenceEqual(
+                    databaseMapping.Model.EntityTypes.Single().DeclaredKeyProperties.Select(
+                        p => p.Name)));
+
+            databaseMapping.Assert<CompositeKeyNoOrder>("CompositeKeyNoOrders").HasColumns(expectedColumnOrder);
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_key_and_order_configured_using_api()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder =>
+                    {
+                        modelBuilder.Entity<CompositeKeyNoOrder>().Property(c => c.Id2).HasColumnOrder(1);
+                        modelBuilder.Entity<CompositeKeyNoOrder>().Property(c => c.Id1).HasColumnOrder(2);
+                        modelBuilder.Entity<CompositeKeyNoOrder>().HasKey(
+                            c => new
+                                     {
+                                         c.Id1,
+                                         c.Id2
+                                     });
+                    },
+                new[] { "Id1", "Id2" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_key_configured_using_api()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder => modelBuilder.Entity<CompositeKeyNoOrder>().HasKey(
+                    c => new
+                             {
+                                 c.Id2,
+                                 c.Id1
+                             }),
+                new[] { "Id2", "Id1" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_order_configured_using_api()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder =>
+                    {
+                        modelBuilder.Entity<CompositeKeyNoOrder>().Property(c => c.Id2).HasColumnOrder(1);
+                        modelBuilder.Entity<CompositeKeyNoOrder>().Property(c => c.Id1).HasColumnOrder(2);
+                    },
+                new[] { "Id2", "Id1" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_key_and_order_configured_using_configuration()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder =>
+                    {
+                        var configuration = new EntityTypeConfiguration<CompositeKeyNoOrder>();
+
+                        configuration.Property(c => c.Id2).HasColumnOrder(1);
+                        configuration.Property(c => c.Id1).HasColumnOrder(2);
+                        configuration.HasKey(
+                            c => new
+                                     {
+                                         c.Id1,
+                                         c.Id2
+                                     });
+
+                        modelBuilder.Configurations.Add(configuration);
+                    },
+                new[] { "Id1", "Id2" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_key_configured_using_configuration()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder =>
+                    {
+                        var configuration = new EntityTypeConfiguration<CompositeKeyNoOrder>();
+
+                        configuration.HasKey(
+                            c => new
+                                     {
+                                         c.Id2,
+                                         c.Id1
+                                     });
+
+                        modelBuilder.Configurations.Add(configuration);
+                    },
+                new[] { "Id2", "Id1" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_result_in_correct_order_when_order_configured_using_configuration()
+        {
+            TestCompositeKeyOrder(
+                modelBuilder =>
+                    {
+                        var configuration = new EntityTypeConfiguration<CompositeKeyNoOrder>();
+
+                        configuration.Property(c => c.Id2).HasColumnOrder(1);
+                        configuration.Property(c => c.Id1).HasColumnOrder(2);
+
+                        modelBuilder.Configurations.Add(configuration);
+                    },
+                new[] { "Id2", "Id1" },
+                new[] { "Id2", "Id1" });
+        }
+
+        [Fact]
+        public void Composite_key_should_throw_when_no_order_configured()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<CompositeKeyNoOrder>();
+
+            Assert.Throws<InvalidOperationException>(
+                () => BuildMapping(modelBuilder))
+                .ValidateMessage("ModelGeneration_UnableToDetermineKeyOrder", typeof(CompositeKeyNoOrder));
+        }
+
+        [Fact]
+        public void HasEntitySetName_configured_using_api()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Entity<UnitMeasure>().HasKey(u => u.UnitMeasureCode);
+            modelBuilder.Entity<UnitMeasure>().HasEntitySetName("Units");
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+
+            Assert.Equal("Units", databaseMapping.Model.Containers.Single().EntitySets.Single().Name);
+        }
+
+        [Fact]
+        public void HasEntitySetName_configured_using_configuration()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            var configuration = new EntityTypeConfiguration<UnitMeasure>();
+
+            configuration.HasKey(u => u.UnitMeasureCode);
+            configuration.HasEntitySetName("Units");
+
+            modelBuilder.Configurations.Add(configuration);
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+
+            Assert.Equal("Units", databaseMapping.Model.Containers.Single().EntitySets.Single().Name);
+        }
+
+        [Fact]
+        public void External_duplicate_association_configuration()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Configurations
+                .Add(new ProductCategoryConfiguration())
+                .Add(new ProductSubcategoryConfiguration());
+
+            BuildMapping(modelBuilder);
+        }
+
+        private class ProductCategoryConfiguration : EntityTypeConfiguration<ProductCategory>
+        {
+            public ProductCategoryConfiguration()
+            {
+                HasMany(p => p.ProductSubcategories)
+                    .WithRequired(s => s.ProductCategory)
+                    .HasForeignKey(s => s.ProductCategoryID);
+            }
+        }
+
+        private class ProductSubcategoryConfiguration : EntityTypeConfiguration<ProductSubcategory>
+        {
+            public ProductSubcategoryConfiguration()
+            {
+                HasRequired(s => s.ProductCategory)
+                    .WithMany(p => p.ProductSubcategories)
+                    .HasForeignKey(s => s.ProductCategoryID);
+            }
+        }
+
+        [Fact]
+        public void Can_call_Entity_after_adding_custom_configuration_class_during_OnModelCreating()
+        {
+            Database.SetInitializer<BasicTypeContext>(null);
+            using (var ctx = new BasicTypeContext())
+            {
+                var oc = ((IObjectContextAdapter)ctx).ObjectContext;
+            }
+        }
+
+        [Fact]
+        public void HasKey_throws_on_collection_nav_prop()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            Assert.Throws<InvalidOperationException>(
+                () => modelBuilder.Entity<Customer>().HasKey(c => c.CustomerAddresses))
+                .ValidateMessage("ModelBuilder_KeyPropertiesMustBePrimitive", "CustomerAddresses", typeof(Customer));
+        }
+
+        [Fact]
+        public void HasKey_throws_on_reference_nav_prop()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            Assert.Throws<InvalidOperationException>(
+                () => modelBuilder.Entity<Customer>().HasKey(c => c.CustomerDiscount))
+                .ValidateMessage("ModelBuilder_KeyPropertiesMustBePrimitive", "CustomerDiscount", typeof(Customer));
+        }
+
+        [Fact]
+        public void HasKey_throws_on_complex_property()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.ComplexType<CustomerDiscount>();
+
+            Assert.Throws<InvalidOperationException>(
+                () => modelBuilder.Entity<Customer>().HasKey(c => c.CustomerDiscount))
+                .ValidateMessage("ModelBuilder_KeyPropertiesMustBePrimitive", "CustomerDiscount", typeof(Customer));
+        }
+
+        [Fact]
+        public void Nested_config_class_with_private_property()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Configurations.Add(new CreditCard.CreditCardConfiguration());
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.Assert<CreditCard>().HasColumn("CardNumber");
+        }
+    }
+
+    #region Fixtures
+
+    public class BasicType
+    {
+        public int Id { get; set; }
+    }
+
+    public class BasicTypeConfiguration : EntityTypeConfiguration<BasicType>
+    {
+        public BasicTypeConfiguration()
+        {
+            ToTable("Blah");
+        }
+    }
+
+    public class BasicTypeContext : DbContext
+    {
+        public DbSet<BasicType> BasicTypes { get; set; }
+
+        private readonly BasicTypeConfiguration _basicTypeConfiguration = new BasicTypeConfiguration();
+
+        internal BasicTypeConfiguration BasicTypeConfiguration
+        {
+            get { return _basicTypeConfiguration; }
+        }
+
+        protected override void OnModelCreating(DbModelBuilder modelBuilder)
+        {
+            modelBuilder.Configurations.Add(BasicTypeConfiguration);
+            modelBuilder.Entity<BasicType>();
+            Assert.Equal("BasicTypes", modelBuilder.ModelConfiguration.Entity(typeof(BasicType)).EntitySetName);
+            Assert.Equal("Blah", modelBuilder.ModelConfiguration.Entity(typeof(BasicType)).GetTableName().Name);
+        }
+    }
+
+    public class CompositeKeyNoOrder
+    {
+        [Key]
+        public int Id1 { get; set; }
+
+        [Key]
+        public int Id2 { get; set; }
+    }
+
+    public abstract class BaseEntity_155894
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "timestamp")]
+        public byte[] Property1 { get; set; }
+    }
+
+    public class DerivedEntity_155894 : BaseEntity_155894
+    {
+        public string Property2 { get; set; }
+    }
+
+    #endregion
+}

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/ConventionsScenarioTests.cs

@@ -0,0 +1,316 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+namespace FunctionalTests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel.DataAnnotations;
+    using System.ComponentModel.DataAnnotations.Schema;
+    using System.Data.Entity;
+    using System.Data.Entity.Core.Metadata.Edm;
+    using System.Data.Entity.Migrations;
+    using System.Data.Entity.ModelConfiguration;
+    using System.Data.Entity.ModelConfiguration.Conventions;
+    using System.Data.Entity.ModelConfiguration.Edm;
+    using System.Data.Entity.Utilities;
+    using System.Linq;
+    using FunctionalTests.Model;
+    using Xunit;
+
+    public class ConventionsScenarioTests : TestBase
+    {
+        [Fact]
+        public void Add_custom_model_convention()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Entity<Customer>();
+            modelBuilder.Conventions.Add<EntitySetNamingConvention>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            Assert.Equal(
+                1,
+                databaseMapping.Model.GetEntitySets().Count(
+                    t => t.Name == "CustomersFoo"));
+        }
+
+        private sealed class EntitySetNamingConvention : IEdmConvention<EntitySet>
+        {
+            public void Apply(EntitySet entitySet, EdmModel model)
+            {
+                entitySet.Name = entitySet.Name + "Foo";
+            }
+        }
+
+        [Fact]
+        public void Add_custom_model_convention_with_ordering()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Entity<CountryRegion>();
+            modelBuilder.Conventions.AddAfter<IdKeyDiscoveryConvention>(new CodeKeyDiscoveryConvention());
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().EntitySetMappings.Count());
+        }
+
+        private sealed class CodeKeyDiscoveryConvention : KeyDiscoveryConvention
+        {
+            private const string Code = "Code";
+
+            protected override EdmProperty MatchKeyProperty(
+                EntityType entityType,
+                IEnumerable<EdmProperty> primitiveProperties)
+            {
+                return primitiveProperties
+                           .SingleOrDefault(p => Code.Equals(p.Name, StringComparison.OrdinalIgnoreCase))
+                       ?? primitiveProperties
+                              .SingleOrDefault(
+                                  p => (entityType.Name + Code).Equals(p.Name, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+
+        [Fact]
+        public void Remove_an_existing_convention()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Entity<Customer>();
+            modelBuilder.Conventions.Remove<IdKeyDiscoveryConvention>();
+
+            Assert.Throws<ModelValidationException>(
+                () => BuildMapping(modelBuilder));
+        }
+
+        [Fact]
+        public void Add_lightweight_convention()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Entities()
+                .Where(t => t == typeof(LightweightEntity))
+                .Configure(e => e.ToTable("TheTable"));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            Assert.True(databaseMapping.Database.GetEntitySets().All(t => t.Table == "TheTable"));
+        }
+
+        [Fact]
+        public void Lightweight_convention_does_not_override_explicit_configurations()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Configurations.Add(new LightweightEntityWithConfiguration.Configuration());
+            modelBuilder.Properties<string>()
+                .Configure(p => p.HasMaxLength(256));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var table
+                = databaseMapping.Database.EntityTypes
+                    .Single(t => t.Name == "LightweightEntityWithConfiguration");
+
+            var attributeColumn = table.Properties.Single(c => c.Name == "PropertyConfiguredByAttribute");
+            Assert.Equal(64, attributeColumn.MaxLength);
+
+            var fluentColumn = table.Properties.Single(c => c.Name == "PropertyConfiguredByFluent");
+            Assert.Equal(128, fluentColumn.MaxLength);
+
+            var unconfiguredColumn = table.Properties.Single(c => c.Name == "PropertyNotConfigured");
+            Assert.Equal(256, unconfiguredColumn.MaxLength);
+        }
+
+        [Fact]
+        public void Can_configure_complex_type_properties()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Properties<string>()
+                .Configure(p => p.HasMaxLength(256));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var column = databaseMapping.Database.EntityTypes
+                .Single()
+                .Properties.Single(c => c.Name == "ComplexProperty_StringProperty");
+            Assert.Equal(256, column.MaxLength);
+        }
+
+        [Fact]
+        public void Lightweight_conventions_can_filter_by_interface()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Entities<ILightweightEntity>()
+                .Configure(c => c.HasKey(e => e.IntProperty));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            Assert.Equal(1, entity.DeclaredKeyProperties.Count());
+            Assert.Equal("IntProperty", entity.DeclaredKeyProperties.Single().Name);
+        }
+
+        [Fact]
+        public void Lightweight_conventions_can_filter_by_object()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Entities<LightweightEntity>()
+                .Configure(c => c.HasKey(e => e.IntProperty));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            Assert.Equal(1, entity.DeclaredKeyProperties.Count());
+            Assert.Equal("IntProperty", entity.DeclaredKeyProperties.Single().Name);
+        }
+
+        [Fact]
+        public void Single_key_configurable_with_isKey()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Properties()
+                .Where(p => p.Name == "IntProperty")
+                .Configure(c => c.IsKey());
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            Assert.Equal(1, entity.DeclaredKeyProperties.Count());
+            Assert.Equal("IntProperty", entity.DeclaredKeyProperties.Single().Name);
+        }
+
+        [Fact]
+        public void Composite_key_configurable_with_isKey()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Properties()
+                .Where(p => p.Name == "IntProperty")
+                .Configure(c => c.HasColumnOrder(0).IsKey());
+
+            modelBuilder.Properties()
+                .Where(p => p.Name == "IntProperty1")
+                .Configure(c => c.HasColumnOrder(1).IsKey());
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            var keys = entity.DeclaredKeyProperties;
+            Assert.Equal(2, keys.Count());
+            Assert.Equal("IntProperty", keys.ElementAt(0).Name);
+            Assert.Equal("IntProperty1", keys.ElementAt(1).Name);
+        }
+
+        [Fact]
+        public void Is_key_is_ignored_if_key_is_already_set()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntityWithKeyConfiguration>();
+            modelBuilder.Properties()
+                .Where(p => p.Name == "IntProperty1")
+                .Configure(c => c.HasColumnOrder(1).IsKey());
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            var keys = entity.DeclaredKeyProperties;
+            Assert.Equal(1, keys.Count());
+            Assert.Equal("IntProperty", keys.ElementAt(0).Name);
+        }
+
+        [Fact]
+        public void HasKey_can_build_composite_keys_filtered_by_interface()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntity>();
+            modelBuilder.Entities<ILightweightEntity>()
+                .Configure(c => c.HasKey(e => new { e.IntProperty, e.IntProperty1 }));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            var keys = entity.DeclaredKeyProperties;
+            Assert.Equal(2, keys.Count());
+            Assert.Equal("IntProperty", keys.First().Name);
+            Assert.Equal("IntProperty1", keys.Last().Name);
+        }
+
+        [Fact]
+        public void HasKey_ignores_rule_if_key_configured_with_annotations()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<LightweightEntityWithKeyConfiguration>();
+            modelBuilder.Entities<ILightweightEntity>()
+                .Configure(c => c.HasKey(e => e.IntProperty));
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var entity = databaseMapping.Model.EntityTypes.Single();
+            var keys = entity.DeclaredKeyProperties;
+            Assert.Equal(1, keys.Count());
+            Assert.Equal("IntProperty", keys.First().Name);
+        }
+    }
+
+    public class LightweightEntityWithConfiguration
+    {
+        public int Id { get; set; }
+
+        [StringLength(64)]
+        public string PropertyConfiguredByAttribute { get; set; }
+
+        public string PropertyConfiguredByFluent { get; set; }
+        public string PropertyNotConfigured { get; set; }
+
+        internal class Configuration : EntityTypeConfiguration<LightweightEntityWithConfiguration>
+        {
+            public Configuration()
+            {
+                Property(e => e.PropertyConfiguredByFluent).HasMaxLength(128);
+            }
+        }
+    }
+
+    public class LightweightComplexType
+    {
+        public string StringProperty { get; set; }
+    }
+
+    public interface ILightweightEntity
+    {
+        int IntProperty { get; set; }
+        int IntProperty1 { get; set; }
+    }
+
+    public class LightweightEntity : ILightweightEntity
+    {
+        public int Id { get; set; }
+        public int IntProperty { get; set; }
+        public int IntProperty1 { get; set; }
+        public LightweightComplexType ComplexProperty { get; set; }
+    }
+
+    public class LightweightEntityWithKeyConfiguration : ILightweightEntity
+    {
+        public int Id { get; set; }
+        [Key, Column(Order = 0)]
+        public int IntProperty { get; set; }
+        public int IntProperty1 { get; set; }
+        public LightweightComplexType ComplexProperty { get; set; }
+    }
+}

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/DataServicesTests.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+namespace FunctionalTests
+{
+    using System.Data.Entity;
+    using System.Data.Entity.Core.Metadata.Edm;
+    using System.Data.Entity.ModelConfiguration.Edm;
+    using System.Data.Services;
+    using System.Data.Services.Common;
+    using Xunit;
+
+    public sealed class DataServicesTests : TestBase
+    {
+        [Fact]
+        public void Validate_Basic_DataServices_Attributes()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<DataServiceFoo>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            var mws = databaseMapping.ToMetadataWorkspace();
+
+            var edmCollection = mws.GetItemCollection(DataSpace.CSpace);
+
+            edmCollection.GetItem<EntityType>("CodeFirstNamespace.DataServiceFoo");
+        }
+    }
+
+    [MimeType("MimeProp", "text/plain")]
+    [HasStream]
+    //[EntityPropertyMappingAttribute("OtherProp", SyndicationItemProperty.AuthorName, true, "critVal")]
+    [EntityPropertyMapping("OtherProp", SyndicationItemProperty.AuthorName,
+        SyndicationTextContentKind.Plaintext, true)]
+    [EntityPropertyMapping("OtherProp", "targetPath3", "prefix3", "http://my.org/", true)]
+    [EntityPropertyMapping("Inner/Data", SyndicationItemProperty.AuthorName,
+        SyndicationTextContentKind.Plaintext, true)]
+    public class DataServiceFoo
+    {
+        public int Id { get; set; }
+
+        public string MimeProp { get; set; }
+
+        public string OtherProp { get; set; }
+
+        public Inner Inner { get; set; }
+    }
+
+    public class Inner
+    {
+        public string Data { get; set; }
+    }
+}

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/EnumsScenarioTests.cs

@@ -0,0 +1,361 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+namespace FunctionalTests
+{
+    using System;
+    using System.Data.Entity;
+    using System.Data.Entity.Core.Metadata.Edm;
+    using System.Data.Entity.ModelConfiguration.Edm;
+    using System.Linq;
+    using FunctionalTests.Fixtures;
+    using Xunit;
+
+    public class EnumsScenarioTests : TestBase
+    {
+        [Fact]
+        public void Simple_enum_mapping_scenario()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Product>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_Product>(p => p.CategoryId).IsTrue(t => t.IsEnumType);
+            databaseMapping.Assert<Enum_Product>().HasColumn("CategoryId");
+
+            var enumType = databaseMapping.Model.GetEnumType("CategoryId");
+
+            Assert.NotNull(enumType);
+            Assert.Equal(7, enumType.Members.Count);
+            Assert.False(enumType.IsFlags);
+            Assert.Equal(PrimitiveTypeKind.Int32, enumType.UnderlyingType.PrimitiveTypeKind);
+        }
+
+        [Fact]
+        public void Short_enum_mapping_with_flags_attribute()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Flags>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+
+            var enumType = databaseMapping.Model.GetEnumType("WithFlags");
+
+            Assert.NotNull(enumType);
+            Assert.Equal(4, enumType.Members.Count);
+            Assert.True(enumType.IsFlags);
+            Assert.Equal(PrimitiveTypeKind.Int16, enumType.UnderlyingType.PrimitiveTypeKind);
+        }
+
+        [Fact]
+        public void Build_model_for_a_single_type_with_a_enum_key()
+        {
+            var modelBuilder = new AdventureWorksModelBuilder();
+
+            modelBuilder.Entity<Enum_Product_PK>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().EntitySetMappings.Count());
+        }
+
+        [Fact]
+        public void Enum_mapped_as_by_convention_fk_in_association()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Fk_Product>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_Fk_Product>().HasForeignKeyColumn("CategoryId");
+        }
+
+        [Fact]
+        public void Enum_mapped_as_by_convention_IA_in_association()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_IA_Principal>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_IA_Dependent>().HasForeignKeyColumn("Principal_Id");
+        }
+
+        [Fact]
+        public void Annotated_nullable_enum_inside_complex_type_is_mapped()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_ComplexEntity>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_ComplexType>(c => c.Enum).IsTrue(t => t.IsEnumType);
+            databaseMapping.Assert<Enum_ComplexType>(c => c.Enum).IsTrue(t => t.Nullable);
+            databaseMapping.Assert<Enum_ComplexType>(c => c.Enum).DbEqual("col_enum", c => c.Name);
+        }
+
+        [Fact]
+        public void Fluent_api_configured_enum_property_gets_correct_facets()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Product>().Property(p => p.CategoryId).IsOptional();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_Product>(p => p.CategoryId).IsTrue(p => p.Nullable);
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_v4_1_model_builder_without_enums()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Product>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            Assert.Equal(2.0, databaseMapping.Model.Version);
+            Assert.Equal(2.0, databaseMapping.Database.Version);
+        }
+
+        [Fact]
+        public void Empty_enum_in_model_does_not_fail_validation()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Empty>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Enum_Empty>(p => p.Empty).IsFalse(e => e.EnumType.Members.Any());
+        }
+
+        [Fact]
+        public void Unsigned_enum_in_model_should_fail_validation()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Enum_Unsigned>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+        }
+
+        [Fact]
+        public void Explicitly_mapping_an_enum_property_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Product>().Property(e => e.CategoryId);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Enum_Product", "CategoryId");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_nullable_enum_property_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Nullable>().Property(e => e.CategoryId);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Enum_Nullable", "CategoryId");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_an_enum_property_on_a_complex_type_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.ComplexType<Enum_ComplexType>().Property(c => c.Enum);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Enum_ComplexType", "Enum");
+        }
+
+        [Fact]
+        public void Explicitly_using_an_enum_property_as_a_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Product>().HasKey(e => e.CategoryId);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Enum_Product", "CategoryId");
+        }
+
+        [Fact]
+        public void Explicitly_using_an_enum_property_as_part_of_a_composite_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Product>().HasKey(
+                e => new
+                         {
+                             e.Id,
+                             e.CategoryId
+                         });
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Enum_Product", "CategoryId");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_an_enum_property_with_Map_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Enum_Product>().Map(
+                mapping =>
+                    {
+                        mapping.ToTable("Table1");
+                        mapping.Properties(e => e.CategoryId);
+                    });
+
+            Assert.Throws<InvalidOperationException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("EntityMappingConfiguration_CannotMapIgnoredProperty", "Enum_Product", "CategoryId");
+        }
+    }
+
+    namespace Fixtures
+    {
+        using System.Collections.Generic;
+        using System.ComponentModel.DataAnnotations.Schema;
+
+        public enum CategoryId
+        {
+            Beverages = 1,
+            Condiments,
+            Confections,
+            Dairy_Products,
+            Grains_Cereals,
+            Meat_Poultry,
+            Produce
+        }
+
+        public enum Empty
+        {
+        }
+
+        public class Enum_Empty
+        {
+            public int Id { get; set; }
+            public Empty Empty { get; set; }
+        }
+
+        public enum Unsigned : uint
+        {
+            Member
+        }
+
+        public class Enum_Unsigned
+        {
+            public int Id { get; set; }
+            public Unsigned Unsigned { get; set; }
+        }
+
+        public class Enum_Product
+        {
+            public int Id { get; set; }
+            public string ProductName { get; set; }
+            public decimal UnitPrice { get; set; }
+            public short UnitsInStock { get; set; }
+            public CategoryId CategoryId { get; set; }
+        }
+
+        public class Enum_Nullable
+        {
+            public int Id { get; set; }
+            public CategoryId? CategoryId { get; set; }
+        }
+
+        [Flags]
+        public enum WithFlags : short
+        {
+            Beverages = 0,
+            Condiments = 1,
+            Confections = 2,
+            Dairy_Products = 4
+        }
+
+        public class Enum_Flags
+        {
+            public int Id { get; set; }
+            public WithFlags FlagsEnum { get; set; }
+        }
+
+        public class Enum_Product_PK
+        {
+            public CategoryId Id { get; set; }
+            public string ProductName { get; set; }
+            public decimal UnitPrice { get; set; }
+            public short UnitsInStock { get; set; }
+        }
+
+        public class Enum_Fk_Product
+        {
+            public int Id { get; set; }
+            public CategoryId CategoryId { get; set; }
+            public Enum_Fk_Category Category { get; set; }
+        }
+
+        public class Enum_Fk_Category
+        {
+            public CategoryId Id { get; set; }
+            public ICollection<Enum_Fk_Product> Products { get; set; }
+        }
+
+        public class Enum_IA_Principal
+        {
+            public CategoryId Id { get; set; }
+            public ICollection<Enum_IA_Dependent> Dependents { get; set; }
+        }
+
+        public class Enum_IA_Dependent
+        {
+            public int Id { get; set; }
+            public Enum_IA_Principal Principal { get; set; }
+        }
+
+        public class Enum_ComplexEntity
+        {
+            public int Id { get; set; }
+            public Enum_ComplexType ComplexType { get; set; }
+        }
+
+        [ComplexType]
+        public class Enum_ComplexType
+        {
+            [Column("col_enum")]
+            public WithFlags? Enum { get; set; }
+        }
+    }
+}

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/CodeFirst/SpatialScenarioTests.cs

@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+namespace FunctionalTests
+{
+    using System;
+    using System.Data.Entity;
+    using FunctionalTests.Fixtures;
+    using Xunit;
+
+    public class SpatialScenarioTests : TestBase
+    {
+        [Fact]
+        public void Simple_spatial_mapping_scenario()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Spatial_Customer>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Spatial_Customer>(c => c.Geography).DbEqual("geography", c => c.TypeName);
+            databaseMapping.Assert<Spatial_Customer>(c => c.Geometry).DbEqual("geometry", c => c.TypeName);
+        }
+
+        [Fact]
+        public void Complex_type_spatial_mapping_scenario()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Spatial_ComplexClass>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Spatial_ComplexType>(c => c.Geography).DbEqual("geography", c => c.TypeName);
+            databaseMapping.Assert<Spatial_ComplexType>(c => c.Geometry).DbEqual("geometry", c => c.TypeName);
+        }
+
+        [Fact]
+        public void Configure_spatial_members_on_type()
+        {
+            var modelBuilder = new DbModelBuilder();
+
+            modelBuilder.Entity<Spatial_Customer>().Property(c => c.Geography).HasColumnName("the_column");
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            databaseMapping.Assert<Spatial_Customer>(c => c.Geography).DbEqual("the_column", c => c.Name);
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_v4_1_model_builder_without_spatials()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>();
+
+            var databaseMapping = BuildMapping(modelBuilder);
+
+            databaseMapping.AssertValid();
+            Assert.Equal(2.0, databaseMapping.Model.Version);
+            Assert.Equal(2.0, databaseMapping.Database.Version);
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeography_property_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().Property(e => e.Geography);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geography");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeography_property_on_a_complex_type_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.ComplexType<Spatial_ComplexType>().Property(c => c.Geography);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_ComplexType", "Geography");
+        }
+
+        [Fact]
+        public void Explicitly_using_a_DbGeography_property_as_a_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().HasKey(e => e.Geography);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geography");
+        }
+
+        [Fact]
+        public void Explicitly_using_a_DbGeography_property_as_part_of_a_composite_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().HasKey(
+                e => new
+                         {
+                             e.Id,
+                             e.Geography
+                         });
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geography");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeography_property_with_Map_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().Map(
+                mapping =>
+                    {
+                        mapping.ToTable("Table1");
+                        mapping.Properties(e => e.Geography);
+                    });
+
+            Assert.Throws<InvalidOperationException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("EntityMappingConfiguration_CannotMapIgnoredProperty", "Spatial_Customer", "Geography");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeometry_property_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().Property(e => e.Geometry);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geometry");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeometry_property_on_a_complex_type_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.ComplexType<Spatial_ComplexType>().Property(c => c.Geometry);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_ComplexType", "Geometry");
+        }
+
+        [Fact]
+        public void Explicitly_using_a_DbGeometry_property_as_a_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().HasKey(e => e.Geometry);
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geometry");
+        }
+
+        [Fact]
+        public void Explicitly_using_a_DbGeometry_property_as_part_of_a_composite_key_with_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().HasKey(
+                e => new
+                         {
+                             e.Id,
+                             e.Geometry
+                         });
+
+            Assert.Throws<NotSupportedException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("UnsupportedUseOfV3Type", "Spatial_Customer", "Geometry");
+        }
+
+        [Fact]
+        public void Explicitly_mapping_a_DbGeometry_property_with_Map_using_4_1_throws()
+        {
+            var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
+
+            modelBuilder.Entity<Spatial_Customer>().Map(
+                mapping =>
+                    {
+                        mapping.ToTable("Table1");
+                        mapping.Properties(e => e.Geometry);
+                    });
+
+            Assert.Throws<InvalidOperationException>(
+                () =>
+                BuildMapping(modelBuilder))
+                .ValidateMessage("EntityMappingConfiguration_CannotMapIgnoredProperty", "Spatial_Customer", "Geometry");
+        }
+    }
+
+    namespace Fixtures
+    {
+        using System.ComponentModel.DataAnnotations;
+        using System.ComponentModel.DataAnnotations.Schema;
+        using System.Data.Entity.Spatial;
+
+        public class Spatial_Customer
+        {
+            public int Id { get; set; }
+            public DbGeometry Geometry { get; set; }
+
+            [Required]
+            public DbGeography Geography { get; set; }
+        }
+
+        public class Spatial_ComplexClass
+        {
+            public int Id { get; set; }
+            public Spatial_ComplexType Complex { get; set; }
+        }
+
+        [ComplexType]
+        public class Spatial_ComplexType
+        {
+            [Column("c")]
+            public DbGeometry Geometry { get; set; }
+
+            public DbGeography Geography { get; set; }
+        }
+    }
+}

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/Metadata/MetadataCachingModel.csdl

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Schema Namespace="MetadataCachingModel" Alias="Self" xmlns:annotation="http://schemas.microsoft.com/ado/2009/02/edm/annotation" xmlns="http://schemas.microsoft.com/ado/2008/09/edm">
+  <EntityContainer Name="Entities" annotation:LazyLoadingEnabled="true">
+    <EntitySet Name="Customers" EntityType="MetadataCachingModel.Customer" />
+  </EntityContainer>
+  <EntityType Name="Customer">
+    <Key>
+      <PropertyRef Name="Id" />
+    </Key>
+    <Property Name="Id" Type="Int32" Nullable="false" annotation:StoreGeneratedPattern="Identity" />
+    <Property Name="Name" Type="String" Nullable="false" />
+  </EntityType>
+</Schema>

external/entityframework/test/EntityFramework/FunctionalTests.Transitional/Metadata/MetadataCachingModel.msl

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Mapping Space="C-S" xmlns="http://schemas.microsoft.com/ado/2008/09/mapping/cs">
+  <EntityContainerMapping StorageEntityContainer="MetadataCachingModelStoreContainer" CdmEntityContainer="Entities">
+    <EntitySetMapping Name="Customers">
+      <EntityTypeMapping TypeName="MetadataCachingModel.Customer">
+        <MappingFragment StoreEntitySet="##Customers">
+          <ScalarProperty Name="Id" ColumnName="Id" />
+          <ScalarProperty Name="Name" ColumnName="Name" />
+        </MappingFragment>
+      </EntityTypeMapping>
+    </EntitySetMapping>
+  </EntityContainerMapping>
+</Mapping>