Added tests for serialization callbacks

Author: Bart Koelman

test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/Serialization/AtomicSerializationResourceDefinitionTests.cs

@@ -0,0 +1,185 @@
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using FluentAssertions;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCoreExample.Controllers;
+using JsonApiDotNetCoreExampleTests.Startups;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using TestBuildingBlocks;
+using Xunit;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions.Serialization
+{
+    public sealed class AtomicSerializationResourceDefinitionTests
+        : IClassFixture<ExampleIntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext>>
+    {
+        private readonly ExampleIntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext> _testContext;
+        private readonly OperationsFakers _fakers = new OperationsFakers();
+
+        public AtomicSerializationResourceDefinitionTests(ExampleIntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext> testContext)
+        {
+            _testContext = testContext;
+
+            testContext.UseController<OperationsController>();
+
+            testContext.ConfigureServicesAfterStartup(services =>
+            {
+                services.AddResourceDefinition<RecordCompanyDefinition>();
+                services.AddScoped(typeof(IResourceChangeTracker<>), typeof(NeverSameResourceChangeTracker<>));
+            });
+        }
+
+        [Fact]
+        public async Task Transforms_in_create_resource_with_side_effects()
+        {
+            // Arrange
+            List<RecordCompany> newCompanies = _fakers.RecordCompany.Generate(2);
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<RecordCompany>();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "recordCompanies",
+                            attributes = new
+                            {
+                                name = newCompanies[0].Name,
+                                countryOfResidence = newCompanies[0].CountryOfResidence
+                            }
+                        }
+                    },
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "recordCompanies",
+                            attributes = new
+                            {
+                                name = newCompanies[1].Name,
+                                countryOfResidence = newCompanies[1].CountryOfResidence
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, AtomicOperationsDocument responseDocument) =
+                await _testContext.ExecutePostAtomicAsync<AtomicOperationsDocument>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Results.Should().HaveCount(2);
+
+            responseDocument.Results[0].SingleData.Attributes["name"].Should().Be(newCompanies[0].Name.ToUpperInvariant());
+            responseDocument.Results[0].SingleData.Attributes["countryOfResidence"].Should().Be(newCompanies[0].CountryOfResidence.ToUpperInvariant());
+
+            responseDocument.Results[1].SingleData.Attributes["name"].Should().Be(newCompanies[1].Name.ToUpperInvariant());
+            responseDocument.Results[1].SingleData.Attributes["countryOfResidence"].Should().Be(newCompanies[1].CountryOfResidence.ToUpperInvariant());
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                List<RecordCompany> companiesInDatabase = await dbContext.RecordCompanies.ToListAsync();
+                companiesInDatabase.Should().HaveCount(2);
+
+                companiesInDatabase[0].Name.Should().Be(newCompanies[0].Name.ToUpperInvariant());
+                companiesInDatabase[0].CountryOfResidence.Should().Be(newCompanies[0].CountryOfResidence);
+
+                companiesInDatabase[1].Name.Should().Be(newCompanies[1].Name.ToUpperInvariant());
+                companiesInDatabase[1].CountryOfResidence.Should().Be(newCompanies[1].CountryOfResidence);
+            });
+        }
+
+        [Fact]
+        public async Task Transforms_in_update_resource_with_side_effects()
+        {
+            // Arrange
+            List<RecordCompany> existingCompanies = _fakers.RecordCompany.Generate(2);
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<RecordCompany>();
+                dbContext.RecordCompanies.AddRange(existingCompanies);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "recordCompanies",
+                            id = existingCompanies[0].StringId,
+                            attributes = new
+                            {
+                            }
+                        }
+                    },
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "recordCompanies",
+                            id = existingCompanies[1].StringId,
+                            attributes = new
+                            {
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, AtomicOperationsDocument responseDocument) =
+                await _testContext.ExecutePostAtomicAsync<AtomicOperationsDocument>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Results.Should().HaveCount(2);
+
+            responseDocument.Results[0].SingleData.Attributes["name"].Should().Be(existingCompanies[0].Name);
+            responseDocument.Results[0].SingleData.Attributes["countryOfResidence"].Should().Be(existingCompanies[0].CountryOfResidence.ToUpperInvariant());
+
+            responseDocument.Results[1].SingleData.Attributes["name"].Should().Be(existingCompanies[1].Name);
+            responseDocument.Results[1].SingleData.Attributes["countryOfResidence"].Should().Be(existingCompanies[1].CountryOfResidence.ToUpperInvariant());
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                List<RecordCompany> companiesInDatabase = await dbContext.RecordCompanies.ToListAsync();
+                companiesInDatabase.Should().HaveCount(2);
+
+                companiesInDatabase[0].Name.Should().Be(existingCompanies[0].Name);
+                companiesInDatabase[0].CountryOfResidence.Should().Be(existingCompanies[0].CountryOfResidence);
+
+                companiesInDatabase[1].Name.Should().Be(existingCompanies[1].Name);
+                companiesInDatabase[1].CountryOfResidence.Should().Be(existingCompanies[1].CountryOfResidence);
+            });
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/Serialization/RecordCompanyDefinition.cs

@@ -0,0 +1,31 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions.Serialization
+{
+    [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+    public sealed class RecordCompanyDefinition : JsonApiResourceDefinition<RecordCompany, short>
+    {
+        public RecordCompanyDefinition(IResourceGraph resourceGraph)
+            : base(resourceGraph)
+        {
+        }
+
+        public override void OnDeserialize(RecordCompany resource)
+        {
+            if (!string.IsNullOrEmpty(resource.Name))
+            {
+                resource.Name = resource.Name.ToUpperInvariant();
+            }
+        }
+
+        public override void OnSerialize(RecordCompany resource)
+        {
+            if (!string.IsNullOrEmpty(resource.CountryOfResidence))
+            {
+                resource.CountryOfResidence = resource.CountryOfResidence.ToUpperInvariant();
+            }
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/AtomicSparseFieldSetResourceDefinitionTests.cs renamed to test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/SparseFieldSets/AtomicSparseFieldSetResourceDefinitionTests.cs

@@ -12,7 +12,7 @@
 using TestBuildingBlocks;
 using Xunit;
 
-namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions.SparseFieldSets
 {
     public sealed class AtomicSparseFieldSetResourceDefinitionTests
         : IClassFixture<ExampleIntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext>>

test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/LyricPermissionProvider.cs renamed to test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/SparseFieldSets/LyricPermissionProvider.cs

@@ -1,4 +1,4 @@
-namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions.SparseFieldSets
 {
     public sealed class LyricPermissionProvider
     {

test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/LyricTextDefinition.cs renamed to test/JsonApiDotNetCoreExampleTests/IntegrationTests/AtomicOperations/ResourceDefinitions/SparseFieldSets/LyricTextDefinition.cs

@@ -3,7 +3,7 @@
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources;
 
-namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.AtomicOperations.ResourceDefinitions.SparseFieldSets
 {
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
     public sealed class LyricTextDefinition : JsonApiResourceDefinition<Lyric, long>

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/AesEncryptionService.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    public sealed class AesEncryptionService : IEncryptionService
+    {
+        private static readonly byte[] CryptoKey = Encoding.UTF8.GetBytes("Secret!".PadRight(32, '-'));
+
+        public string Encrypt(string value)
+        {
+            using SymmetricAlgorithm cipher = CreateCipher();
+
+            using ICryptoTransform transform = cipher.CreateEncryptor();
+            byte[] plaintext = Encoding.UTF8.GetBytes(value);
+            byte[] cipherText = transform.TransformFinalBlock(plaintext, 0, plaintext.Length);
+
+            byte[] buffer = new byte[cipher.IV.Length + cipherText.Length];
+            Buffer.BlockCopy(cipher.IV, 0, buffer, 0, cipher.IV.Length);
+            Buffer.BlockCopy(cipherText, 0, buffer, cipher.IV.Length, cipherText.Length);
+
+            return Convert.ToBase64String(buffer);
+        }
+
+        public string Decrypt(string value)
+        {
+            byte[] buffer = Convert.FromBase64String(value);
+
+            using SymmetricAlgorithm cipher = CreateCipher();
+
+            byte[] initVector = new byte[cipher.IV.Length];
+            Buffer.BlockCopy(buffer, 0, initVector, 0, initVector.Length);
+            cipher.IV = initVector;
+
+            using ICryptoTransform transform = cipher.CreateDecryptor();
+            byte[] plainBytes = transform.TransformFinalBlock(buffer, initVector.Length, buffer.Length - initVector.Length);
+
+            return Encoding.UTF8.GetString(plainBytes);
+        }
+
+        private static SymmetricAlgorithm CreateCipher()
+        {
+            var cipher = Aes.Create();
+            cipher.Key = CryptoKey;
+
+            return cipher;
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/IEncryptionService.cs

@@ -0,0 +1,8 @@
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    public interface IEncryptionService
+    {
+        string Encrypt(string value);
+        string Decrypt(string value);
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/Scholarship.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Scholarship : Identifiable
+    {
+        [Attr]
+        public string ProgramName { get; set; }
+
+        [Attr]
+        public decimal Amount { get; set; }
+
+        [HasMany]
+        public IList<Student> Participants { get; set; }
+
+        [HasOne]
+        public Student PrimaryContact { get; set; }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/ScholarshipsController.cs

@@ -0,0 +1,15 @@
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Controllers;
+using JsonApiDotNetCore.Services;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    public sealed class ScholarshipsController : JsonApiController<Scholarship>
+    {
+        public ScholarshipsController(IJsonApiOptions options, ILoggerFactory loggerFactory, IResourceService<Scholarship> resourceService)
+            : base(options, loggerFactory, resourceService)
+        {
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/SerializationDbContext.cs

@@ -0,0 +1,26 @@
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore;
+
+// @formatter:wrap_chained_method_calls chop_always
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class SerializationDbContext : DbContext
+    {
+        public DbSet<Student> Students { get; set; }
+        public DbSet<Scholarship> Scholarships { get; set; }
+
+        public SerializationDbContext(DbContextOptions<SerializationDbContext> options)
+            : base(options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            builder.Entity<Scholarship>()
+                .HasMany(scholarship => scholarship.Participants)
+                .WithOne(student => student.Scholarship);
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Serialization/SerializationFakers.cs

@@ -0,0 +1,28 @@
+using System;
+using Bogus;
+using Bogus.Extensions.UnitedStates;
+using TestBuildingBlocks;
+
+// @formatter:wrap_chained_method_calls chop_always
+// @formatter:keep_existing_linebreaks true
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Serialization
+{
+    internal sealed class SerializationFakers : FakerContainer
+    {
+        private readonly Lazy<Faker<Student>> _lazyStudentFaker = new Lazy<Faker<Student>>(() =>
+            new Faker<Student>()
+                .UseSeed(GetFakerSeed())
+                .RuleFor(student => student.Name, faker => faker.Person.FullName)
+                .RuleFor(student => student.SocialSecurityNumber, faker => faker.Person.Ssn()));
+
+        private readonly Lazy<Faker<Scholarship>> _lazyScholarshipFaker = new Lazy<Faker<Scholarship>>(() =>
+            new Faker<Scholarship>()
+                .UseSeed(GetFakerSeed())
+                .RuleFor(scholarship => scholarship.ProgramName, faker => faker.Commerce.Department())
+                .RuleFor(scholarship => scholarship.Amount, faker => faker.Finance.Amount()));
+
+        public Faker<Student> Student => _lazyStudentFaker.Value;
+        public Faker<Scholarship> Scholarship => _lazyScholarshipFaker.Value;
+    }
+}