Fixed null reference in IdentifierValueConverter

Author: Henk Kin

Identifiers.EntityFrameworkCore.SqlServer.Tests/IdentifierMigrationsAnnotationProviderTests.cs

@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Linq;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Xunit;
+
+namespace Identifiers.EntityFrameworkCore.SqlServer.Tests
+{
+    public class IdentifierMigrationsAnnotationProviderTests
+    {
+        [Fact]
+        public void For_WhenCalledWithoutExistingAnnotation_ItShouldReturnExistingAnnotations()
+        {
+            // Arrange
+            var identifierMigrationsAnnotationProvider = new IdentifierMigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies());
+            var entityType = new EntityType(typeof(object), new Model(), ConfigurationSource.DataAnnotation);
+            IProperty property = new Property("id", typeof(int), null, null, entityType, ConfigurationSource.DataAnnotation, null);
+
+            // Act
+            var results = identifierMigrationsAnnotationProvider.For(property);
+
+            // Assert
+            Assert.Empty(results);
+        }
+
+        [Fact]
+        public void For_WhenCalledForPropertyWithExistingAnnotations_ItShouldReturnExistingAnnotations()
+        {
+            // Arrange
+            var identifierMigrationsAnnotationProvider = new IdentifierMigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies());
+
+            var conventionSet = new ConventionSet();
+            var entityType = new EntityType(typeof(Entity), new Model(conventionSet), ConfigurationSource.DataAnnotation);
+            
+            Property property = new Property("Id", typeof(int), null, null, entityType, ConfigurationSource.DataAnnotation, null);
+            property.AddAnnotation("Identifier", 12);
+
+            // Act
+            var results = identifierMigrationsAnnotationProvider.For(property).ToList();
+
+            // Assert
+            Assert.Single(results);
+            Assert.Equal("SqlServer:ValueGenerationStrategy", results.First().Name);
+            Assert.Equal(12, results.First().Value);
+        }
+
+        public class Entity
+        {
+            public int Id { get; set; }
+        }
+    }
+}

Identifiers.EntityFrameworkCore.SqlServer.Tests/IdentifierPropertyBuilderExtensionsTests.cs

@@ -0,0 +1,72 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Xunit;
+
+namespace Identifiers.EntityFrameworkCore.SqlServer.Tests
+{
+    public class IdentifierPropertyBuilderExtensionsTests
+    {
+        [Fact]
+        public void WhenNotCalled_ItShouldHaveDefaultSituation()
+        {
+            // Arrange
+            var entityType = new EntityType("Entity", new Model(), ConfigurationSource.DataAnnotation);
+
+            // Act
+            var result = new PropertyBuilder<Identifier>(new Property("Id", typeof(Identifier), null, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention));
+
+            // Assert
+            Assert.Equal(ValueGenerated.Never, result.Metadata.ValueGenerated);
+            Assert.Null(result.Metadata.FindAnnotation("Identifier"));
+            Assert.Equal(PropertySaveBehavior.Save, result.Metadata.GetBeforeSaveBehavior());
+        }
+
+        [Fact]
+        public void WhenCalled_ItShouldSetValueGeneratedToOnAdd()
+        {
+            // Arrange
+            var entityType = new EntityType("Entity", new Model(), ConfigurationSource.DataAnnotation);
+            var propertyBuilder = new PropertyBuilder<Identifier>(new Property("Id", typeof(Identifier), null, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention));
+
+            // Act
+            var result = propertyBuilder.IdentifierValueGeneratedOnAdd();
+
+            // Assert
+            Assert.Equal(ValueGenerated.OnAdd, result.Metadata.ValueGenerated);
+        }
+
+        [Fact]
+        public void WhenCalled_ItShouldAddIdentifierAnnotation()
+        {
+            // Arrange
+            var entityType = new EntityType("Entity", new Model(), ConfigurationSource.DataAnnotation);
+            var propertyBuilder = new PropertyBuilder<Identifier>(new Property("Id", typeof(Identifier), null, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention));
+
+            // Act
+            var result = propertyBuilder.IdentifierValueGeneratedOnAdd();
+
+            // Assert
+            var identifierAnnotation = result.Metadata.FindAnnotation("Identifier");
+            Assert.NotNull(identifierAnnotation);
+            Assert.Equal("Identifier", identifierAnnotation.Name);
+            Assert.Equal(SqlServerValueGenerationStrategy.IdentityColumn, identifierAnnotation.Value);
+        }
+
+
+        [Fact]
+        public void WhenCalled_ItShouldSetBeforeSaveBehaviorToIgnore()
+        {
+            // Arrange
+            var entityType = new EntityType("Entity", new Model(), ConfigurationSource.DataAnnotation);
+            var propertyBuilder = new PropertyBuilder<Identifier>(new Property("Id", typeof(Identifier), null, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention));
+
+            // Act
+            var result = propertyBuilder.IdentifierValueGeneratedOnAdd();
+
+            // Assert
+            Assert.Equal(PropertySaveBehavior.Ignore, result.Metadata.GetBeforeSaveBehavior());
+        }
+    }
+}

Identifiers.EntityFrameworkCore.SqlServer.Tests/IdentifierSqlServerDbContextOptionsExtensionsTests.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.SqlServer.Migrations.Internal;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Identifiers.EntityFrameworkCore.SqlServer.Tests
+{
+    public class IdentifierSqlServerDbContextOptionsExtensionsTests
+    {
+        [Fact]
+        public void WhenNotCalled_ItShouldHaveDefaultSituation()
+        {
+            // Arrange
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection.AddDbContext<TestDbContext>(builder =>
+                builder.UseSqlServer("TestDatabase")
+            );
+
+            var serviceProvider = serviceCollection.BuildServiceProvider();
+            var testDbContext = serviceProvider.GetRequiredService<TestDbContext>();
+
+            // Act
+            var migrationsAnnotationProvider = testDbContext.GetService<IMigrationsAnnotationProvider>();
+            var valueConverterSelector = testDbContext.GetService<IValueConverterSelector>();
+
+            // Assert
+            Assert.NotNull(testDbContext);
+            Assert.NotEqual(typeof(IdentifierMigrationsAnnotationProvider), migrationsAnnotationProvider.GetType());
+            Assert.Equal(typeof(SqlServerMigrationsAnnotationProvider), migrationsAnnotationProvider.GetType());
+            Assert.NotEqual(typeof(IdentifierValueConverterSelector<int>), valueConverterSelector.GetType());
+            Assert.Equal(typeof(ValueConverterSelector), valueConverterSelector.GetType());
+        }
+
+        [Fact]
+        public void WhenCalled_ItShouldRegisterIdentifierMigrationsAnnotationProvider()
+        {
+            // Arrange
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection.AddDbContext<TestDbContext>(builder =>
+                builder.UseSqlServer("TestDatabase")
+                    .UseIdentifiers<int>());
+
+            var serviceProvider = serviceCollection.BuildServiceProvider();
+            var testDbContext = serviceProvider.GetRequiredService<TestDbContext>();
+
+            // Act
+            var migrationsAnnotationProvider = testDbContext.GetService<IMigrationsAnnotationProvider>();
+
+            // Assert
+            Assert.NotNull(testDbContext);
+
+            Assert.Equal(typeof(IdentifierMigrationsAnnotationProvider), migrationsAnnotationProvider.GetType());
+        }
+
+
+        [Fact]
+        public void WhenCalled_ItShouldRegisterIdentifierValueConverterSelector()
+        {
+            // Arrange
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection.AddDbContext<TestDbContext>(builder =>
+                builder.UseSqlServer("TestDatabase")
+                    .UseIdentifiers<int>());
+
+            var serviceProvider = serviceCollection.BuildServiceProvider();
+            var testDbContext = serviceProvider.GetRequiredService<TestDbContext>();
+
+            // Act
+            var valueConverterSelector = testDbContext.GetService<IValueConverterSelector>();
+            
+            // Assert
+            Assert.NotNull(testDbContext);
+            Assert.Equal(typeof(IdentifierValueConverterSelector<int>), valueConverterSelector.GetType());
+        }
+
+        public class TestDbContext : DbContext
+        {
+            public TestDbContext(DbContextOptions<TestDbContext> options) : base(options)
+            {
+                
+            }
+        }
+    }
+}

Identifiers.EntityFrameworkCore.SqlServer.Tests/IdentifierValueConverterSelectorTests.cs

@@ -0,0 +1,87 @@
+using System.Linq;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Xunit;
+
+namespace Identifiers.EntityFrameworkCore.SqlServer.Tests
+{
+    public class IdentifierValueConverterSelectorTests
+    {
+        [Fact]
+        public void WhenCalledForIdentifier_ItShouldReturnAValueConverterInfo()
+        {
+            // Arrange
+            var identifierValueConverterSelector = new IdentifierValueConverterSelector<int>(new ValueConverterSelectorDependencies());
+
+            // Act
+            var results = identifierValueConverterSelector.Select(typeof(Identifier)).ToList();
+
+            // Assert
+            Assert.Equal(typeof(int), results.Single().ProviderClrType);
+            Assert.Equal(typeof(Identifier), results.Single().ModelClrType);
+            Assert.Null(results.Single().MappingHints);
+        }
+
+        [Fact]
+        public void WhenCalledForNullableIdentifier_ItShouldReturnAValueConverterInfo()
+        {
+            // Arrange
+            var identifierValueConverterSelector = new IdentifierValueConverterSelector<int>(new ValueConverterSelectorDependencies());
+
+            // Act
+            var results = identifierValueConverterSelector.Select(typeof(Identifier?)).ToList();
+
+            // Assert
+            Assert.Equal(typeof(int), results.Single().ProviderClrType);
+            Assert.Equal(typeof(Identifier?), results.Single().ModelClrType);
+            Assert.Null(results.Single().MappingHints);
+        }
+
+        [Fact]
+        public void WhenCalledForNullableIdentifierAndWithProviderType_ItShouldReturnAValueConverterInfo()
+        {
+            // Arrange
+            var identifierValueConverterSelector = new IdentifierValueConverterSelector<int>(new ValueConverterSelectorDependencies());
+
+            // Act
+            var results = identifierValueConverterSelector.Select(typeof(Identifier?), typeof(int)).ToList();
+
+            // Assert
+            Assert.Equal(typeof(int), results.Single().ProviderClrType);
+            Assert.Equal(typeof(Identifier?), results.Single().ModelClrType);
+            Assert.Null(results.Single().MappingHints);
+        }
+        
+        [Fact]
+        public void WhenCalledForIdentifierAndFactoryIsUsed_ItShouldCreateAValueConverter()
+        {
+            // Arrange
+            var identifierValueConverterSelector = new IdentifierValueConverterSelector<int>(new ValueConverterSelectorDependencies());
+            var results = identifierValueConverterSelector.Select(typeof(Identifier)).ToList();
+            var valueConverterInfo = results.Single();
+
+            // Act
+            var valueConverter = valueConverterInfo.Create();
+
+            // Assert
+            Assert.NotNull(valueConverter);
+            Assert.NotNull(valueConverter.MappingHints);
+            Assert.Equal(typeof(int), valueConverter.ProviderClrType);
+            Assert.Equal(typeof(Identifier), valueConverter.ModelClrType);
+            Assert.Null(results.Single().MappingHints);
+        }
+
+        [Fact]
+        public void WhenCalledForInteger_ItShouldReturnDefaultValueConverterInfos()
+        {
+            // Arrange
+            var identifierValueConverterSelector = new IdentifierValueConverterSelector<int>(new ValueConverterSelectorDependencies());
+
+            // Act
+            var results = identifierValueConverterSelector.Select(typeof(int)).ToList();
+
+            // Assert
+            Assert.Equal(12, results.Count);
+            Assert.True(results.All(x=>x.ModelClrType == typeof(int)));
+        }
+    }
+}