add tests for bulk operations

Author: jaredcnance

Build.ps1

@@ -32,6 +32,9 @@ CheckLastExitCode
 dotnet test ./test/NoEntityFrameworkTests/NoEntityFrameworkTests.csproj
 CheckLastExitCode
 
+dotnet test ./test/OperationsExampleTests/OperationsExampleTests.csproj
+CheckLastExitCode
+
 dotnet build .\src\JsonApiDotNetCore -c Release
 CheckLastExitCode
 
@@ -57,4 +60,4 @@ Else {
     Write-Output "RUNNING dotnet pack .\src\JsonApiDotNetCore -c Release -o .\artifacts --version-suffix=alpha1-$revision"
     dotnet pack .\src\JsonApiDotNetCore -c Release -o .\artifacts --version-suffix=alpha1-$revision 
     CheckLastExitCode
-}
+}

JsonApiDotnetCore.sln

@@ -15,6 +15,10 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C5B4D998-CECB-454D-9F32-085A897577BE}"
 	ProjectSection(SolutionItems) = preProject
 		.gitignore = .gitignore
+		.travis.yml = .travis.yml
+		appveyor.yml = appveyor.yml
+		Build.ps1 = Build.ps1
+		build.sh = build.sh
 		Directory.Build.props = Directory.Build.props
 		README.md = README.md
 	EndProjectSection

build.sh

@@ -7,4 +7,5 @@ dotnet restore
 
 dotnet test ./test/UnitTests/UnitTests.csproj
 dotnet test ./test/JsonApiDotNetCoreExampleTests/JsonApiDotNetCoreExampleTests.csproj
-dotnet test ./test/NoEntityFrameworkTests/NoEntityFrameworkTests.csproj
+dotnet test ./test/NoEntityFrameworkTests/NoEntityFrameworkTests.csproj
+dotnet test ./test/OperationsExampleTests/OperationsExampleTests.csproj

src/JsonApiDotNetCore/Controllers/JsonApiOperationsController.cs

@@ -5,18 +5,50 @@
 
 namespace JsonApiDotNetCore.Controllers
 {
+    /// <summary>
+    /// A controller to be used for bulk operations as defined in the json:api 1.1 specification
+    /// </summary>
     public class JsonApiOperationsController : Controller
     {
         private readonly IOperationsProcessor _operationsProcessor;
 
-        public JsonApiOperationsController(
-            IOperationsProcessor operationsProcessor)
+        /// <param name="operationsProcessor">
+        /// The processor to handle bulk operations.
+        /// </param>
+        public JsonApiOperationsController(IOperationsProcessor operationsProcessor)
         {
             _operationsProcessor = operationsProcessor;
         }
 
+        /// <summary>
+        /// Bulk endpoint for json:api operations
+        /// </summary>
+        /// <param name="doc">
+        /// A json:api operations request document
+        /// </param>
+        /// <example>
+        /// <code>
+        /// PATCH /api/bulk HTTP/1.1
+        /// Content-Type: application/vnd.api+json
+        /// 
+        /// {
+        ///   "operations": [{
+        ///     "op": "add",
+        ///     "ref": {
+        ///       "type": "authors"
+        ///     },
+        ///     "data": {
+        ///       "type": "authors",
+        ///       "attributes": {
+        ///         "name": "jaredcnance"
+        ///       }
+        ///     }
+        ///   }]
+        /// }
+        /// </code>
+        /// </example>
         [HttpPatch]
-        public async Task<IActionResult> PatchAsync([FromBody] OperationsDocument doc)
+        public virtual async Task<IActionResult> PatchAsync([FromBody] OperationsDocument doc)
         {
             if (doc == null) return new StatusCodeResult(422);
 

test/OperationsExampleTests/Add/AddTests.cs

@@ -3,7 +3,6 @@
 using System.Net;
 using System.Threading.Tasks;
 using Bogus;
-using JsonApiDotNetCore.Extensions;
 using JsonApiDotNetCore.Models.Operations;
 using Microsoft.EntityFrameworkCore;
 using OperationsExample.Data;
@@ -24,20 +23,20 @@ public AddTests(Fixture fixture)
         }
 
         [Fact]
-        public async Task Can_Create_Article()
+        public async Task Can_Create_Author()
         {
             // arrange
             var context = _fixture.GetService<AppDbContext>();
-            var article = ArticleFactory.Get();
+            var author = AuthorFactory.Get();
             var content = new
             {
                 operations = new[] {
                     new {
                         op = "add",
                         data = new {
-                            type = "articles",
+                            type = "authors",
                             attributes = new {
-                                name = article.Name
+                                name = author.Name
                             }
                         }
                     }
@@ -48,21 +47,21 @@ public async Task Can_Create_Article()
             var result = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
 
             // assert
-            Assert.NotNull(result);
+            Assert.NotNull(result.response);
             Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
 
-            var id = (string)result.data.Operations.Single().DataObject.Id;
-            var lastArticle = await context.Articles.SingleAsync(a => a.StringId == id);
-            Assert.Equal(article.Name, lastArticle.Name);
+            var id = result.data.Operations.Single().DataObject.Id;
+            var lastAuthor = await context.Authors.SingleAsync(a => a.StringId == id);
+            Assert.Equal(author.Name, lastAuthor.Name);
         }
 
         [Fact]
-        public async Task Can_Create_Articles()
+        public async Task Can_Create_Authors()
         {
             // arrange
             var expectedCount = _faker.Random.Int(1, 10);
             var context = _fixture.GetService<AppDbContext>();
-            var articles = ArticleFactory.Get(expectedCount);
+            var authors = AuthorFactory.Get(expectedCount);
             var content = new
             {
                 operations = new List<object>()
@@ -76,30 +75,97 @@ public async Task Can_Create_Articles()
                          op = "add",
                          data = new
                          {
-                             type = "articles",
+                             type = "authors",
                              attributes = new
                              {
-                                 name = articles[i].Name
+                                 name = authors[i].Name
                              }
                          }
                      }
                 );
             }
 
             // act
-            var result = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
+            var (response, data) = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
 
             // assert
-            Assert.NotNull(result);
-            Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
-            Assert.Equal(expectedCount, result.data.Operations.Count);
+            Assert.NotNull(response);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(expectedCount, data.Operations.Count);
 
             for (int i = 0; i < expectedCount; i++)
             {
-                var data = result.data.Operations[i].DataObject;
-                var article = context.Articles.Single(a => a.StringId == data.Id.ToString());
-                Assert.Equal(articles[i].Name, article.Name);
+                var dataObject = data.Operations[i].DataObject;
+                var author = context.Authors.Single(a => a.StringId == dataObject.ToString());
+                Assert.Equal(authors[i].Name, author.Name);
             }
+        }
+
+        [Fact]
+        public async Task Can_Create_Author_With_Article()
+        {
+            // arrange
+            var context = _fixture.GetService<AppDbContext>();
+            var author = AuthorFactory.Get();
+            var article = ArticleFactory.Get();
+            const string authorLocalId = "author-1";
+
+            var content = new
+            {
+                operations = new object[] {
+                    new {
+                        op = "add",
+                        data = new {
+                            lid = authorLocalId,
+                            type = "authors",
+                            attributes = new {
+                                name = author.Name
+                            },
+                        }
+                    },
+                    new {
+                        op = "add",
+                        data = new {
+                            type = "articles",
+                            attributes = new {
+                                name = article.Name
+                            },
+                            relationships = new {
+                                author = new {
+                                    data = new {
+                                        type = "authors",
+                                        lid = authorLocalId
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            // act
+            var (response, data) = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
+
+            // assert
+            Assert.NotNull(response);
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Equal(2, data.Operations.Count);
+
+            var authorOperationResult = data.Operations[0];
+            var id = authorOperationResult.DataObject.Id;
+            var lastAuthor = await context.Authors
+                .Include(a => a.Articles)
+                .SingleAsync(a => a.StringId == id);
+            var articleOperationResult = data.Operations[1];
+
+            // author validation
+            Assert.Equal(authorLocalId, authorOperationResult.DataObject.LocalId);
+            Assert.Equal(author.Name, lastAuthor.Name);
+
+            // article validation
+            Assert.Equal(1, lastAuthor.Articles.Count);
+            Assert.Equal(article.Name, lastAuthor.Articles[0].Name);
+            Assert.Equal(articleOperationResult.DataObject.Id, lastAuthor.Articles[0].StringId);
         }
     }
 }

test/OperationsExampleTests/Factories/AuthorFactory.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Bogus;
+using OperationsExample.Models;
+
+namespace OperationsExampleTests.Factories
+{
+    public static class AuthorFactory
+    {
+        public static Author Get()
+        {
+            var faker = new Faker<Author>();
+            faker.RuleFor(m => m.Name, f => f.Person.UserName);
+            return faker.Generate();
+        }
+
+        public static List<Author> Get(int count)
+        {
+            var authors = new List<Author>();
+            for (int i = 0; i < count; i++)
+                authors.Add(Get());
+
+            return authors;
+        }
+    }
+}