test(default-entity-repository): add UpdateAsync tests

Author: jaredcnance

test/UnitTests/Data/DefaultEntityRepository_Tests.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using JsonApiDotNetCore.Controllers;
+using JsonApiDotNetCore.Internal;
+using Microsoft.AspNetCore.Mvc;
+using Xunit;
+using Moq;
+using Microsoft.EntityFrameworkCore;
+using JsonApiDotNetCoreExample.Models;
+using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Data;
+using JsonApiDotNetCore.Models;
+using Microsoft.Extensions.Logging;
+using JsonApiDotNetCore.Services;
+using System.Threading.Tasks;
+
+namespace UnitTests.Data
+{
+    public class DefaultEntityRepository_Tests : JsonApiControllerMixin
+    {
+        private readonly Mock<IJsonApiContext> _jsonApiContextMock;
+        private readonly Mock<ILoggerFactory> _loggFactoryMock;
+        private readonly Mock<DbSet<TodoItem>> _dbSetMock;
+        private readonly Mock<DbContext> _contextMock;
+        private readonly Mock<IDbContextResolver> _contextResolverMock;
+        private readonly TodoItem _todoItem;
+        private Dictionary<AttrAttribute, object> _attrsToUpdate = new Dictionary<AttrAttribute, object>();
+        private Dictionary<RelationshipAttribute, object> _relationshipsToUpdate = new Dictionary<RelationshipAttribute, object>();
+
+        public DefaultEntityRepository_Tests()
+        {
+            _todoItem = new TodoItem
+            {
+                Id = 1,
+                Description = Guid.NewGuid().ToString(),
+                Ordinal = 10
+            };
+            _jsonApiContextMock = new Mock<IJsonApiContext>();
+            _loggFactoryMock = new Mock<ILoggerFactory>();
+            _dbSetMock = DbSetMock.Create<TodoItem>(new[] { _todoItem });
+            _contextMock = new Mock<DbContext>();
+            _contextResolverMock = new Mock<IDbContextResolver>();
+        }
+
+        [Fact]
+        public async Task UpdateAsync_Updates_Attributes_In_AttributesToUpdate()
+        {
+            // arrange
+            var todoItemUpdates = new TodoItem
+            {
+                Id = _todoItem.Id,
+                Description = Guid.NewGuid().ToString()
+            };
+
+            _attrsToUpdate = new Dictionary<AttrAttribute, object> 
+            {
+                {
+                    new AttrAttribute("description", "Description"),
+                    todoItemUpdates.Description
+                }
+            };
+
+            var repository = GetRepository();
+
+            // act
+            var updatedItem = await repository.UpdateAsync(_todoItem.Id, todoItemUpdates);
+
+            // assert
+            Assert.NotNull(updatedItem);
+            Assert.Equal(_todoItem.Ordinal, updatedItem.Ordinal);
+            Assert.Equal(todoItemUpdates.Description, updatedItem.Description);
+        }
+
+        private DefaultEntityRepository<TodoItem> GetRepository()
+        {
+            _contextResolverMock
+                .Setup(m => m.GetContext())
+                .Returns(_contextMock.Object);
+
+            _contextResolverMock
+                .Setup(m => m.GetDbSet<TodoItem>())
+                .Returns(_dbSetMock.Object);
+
+            _jsonApiContextMock
+               .Setup(m => m.AttributesToUpdate)
+               .Returns(_attrsToUpdate);
+
+            _jsonApiContextMock
+                .Setup(m => m.RelationshipsToUpdate)
+                .Returns(_relationshipsToUpdate);
+
+            _jsonApiContextMock
+                .Setup(m => m.GetDbContextResolver())
+                .Returns(_contextResolverMock.Object);
+
+            return new DefaultEntityRepository<TodoItem>(
+                _loggFactoryMock.Object,
+                _jsonApiContextMock.Object);
+        }
+    }
+}

test/UnitTests/DbSetMock.cs

@@ -0,0 +1,122 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Query.Internal;
+using Moq;
+
+public static class DbSetMock
+{
+    public static Mock<DbSet<T>> Create<T>(params T[] elements) where T : class
+    {
+        return new List<T>(elements).AsDbSetMock();
+    }
+}
+ 
+public static class ListExtensions
+{
+    public static Mock<DbSet<T>> AsDbSetMock<T>(this List<T> list) where T : class
+    {
+        IQueryable<T> queryableList = list.AsQueryable();
+        Mock<DbSet<T>> dbSetMock = new Mock<DbSet<T>>();
+        
+        dbSetMock.As<IQueryable<T>>().Setup(x => x.Expression).Returns(queryableList.Expression);
+        dbSetMock.As<IQueryable<T>>().Setup(x => x.ElementType).Returns(queryableList.ElementType);
+        dbSetMock.As<IQueryable<T>>().Setup(x => x.GetEnumerator()).Returns(queryableList.GetEnumerator());
+        
+        dbSetMock.As<IAsyncEnumerable<T>>().Setup(m => m.GetEnumerator()).Returns(new TestAsyncEnumerator<T>(queryableList.GetEnumerator()));
+        dbSetMock.As<IQueryable<T>>().Setup(m => m.Provider).Returns(new TestAsyncQueryProvider<T>(queryableList.Provider));
+        return dbSetMock;
+    }
+}
+
+internal class TestAsyncQueryProvider<TEntity> : IAsyncQueryProvider
+{
+    private readonly IQueryProvider _inner;
+
+    internal TestAsyncQueryProvider(IQueryProvider inner)
+    {
+        _inner = inner;
+    }
+
+    public IQueryable CreateQuery(Expression expression)
+    {
+        return new TestAsyncEnumerable<TEntity>(expression);
+    }
+
+    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
+    {
+        return new TestAsyncEnumerable<TElement>(expression);
+    }
+
+    public object Execute(Expression expression)
+    {
+        return _inner.Execute(expression);
+    }
+
+    public TResult Execute<TResult>(Expression expression)
+    {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
+    {
+        return new TestAsyncEnumerable<TResult>(expression);
+    }
+
+    public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(Execute<TResult>(expression));
+    }
+}
+
+internal class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T>
+{
+    public TestAsyncEnumerable(IEnumerable<T> enumerable)
+        : base(enumerable)
+    { }
+
+    public TestAsyncEnumerable(Expression expression)
+        : base(expression)
+    { }
+
+    public IAsyncEnumerator<T> GetEnumerator()
+    {
+        return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
+    }
+
+    IQueryProvider IQueryable.Provider
+    {
+        get { return new TestAsyncQueryProvider<T>(this); }
+    }
+}
+
+internal class TestAsyncEnumerator<T> : IAsyncEnumerator<T>
+{
+    private readonly IEnumerator<T> _inner;
+
+    public TestAsyncEnumerator(IEnumerator<T> inner)
+    {
+        _inner = inner;
+    }
+
+    public void Dispose()
+    {
+        _inner.Dispose();
+    }
+
+    public T Current
+    {
+        get
+        {
+            return _inner.Current;
+        }
+    }
+
+    public Task<bool> MoveNext(CancellationToken cancellationToken)
+    {
+        return Task.FromResult(_inner.MoveNext());
+    }
+}

test/UnitTests/UnitTests.csproj

@@ -1,19 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <TargetFramework>netcoreapp1.1</TargetFramework>
-
     <IsPackable>false</IsPackable>
   </PropertyGroup>
-
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170427-09" />
+    <PackageReference Include="moq" Version="4.7.10" />
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
   </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\..\src\JsonApiDotNetCore\JsonApiDotNetCore.csproj" />
+    <ProjectReference Include="..\..\src\JsonApiDotNetCoreExample\JsonApiDotNetCoreExample.csproj" />
   </ItemGroup>
-
-</Project>
+</Project>