CachedRepositoryTests and small refactoring

Author: linkdotnet

LinkDotNet.Blog.Infrastructure/Persistence/CachedRepository.cs

@@ -21,14 +21,13 @@ public CachedRepository(IRepository<T> repository, IMemoryCache memoryCache)
 
         public async Task<T> GetByIdAsync(string id)
         {
-            if (memoryCache.TryGetValue(id, out T item))
+            if (!memoryCache.TryGetValue(id, out T value))
             {
-                return item;
+                value = await repository.GetByIdAsync(id);
+                memoryCache.Set(id, value);
             }
 
-            var fromDb = await repository.GetByIdAsync(id);
-            memoryCache.Set(id, fromDb);
-            return fromDb;
+            return value;
         }
 
         public async Task<IPagedList<T>> GetAllAsync(
@@ -38,24 +37,26 @@ public async Task<IPagedList<T>> GetAllAsync(
             int page = 1,
             int pageSize = int.MaxValue)
         {
-            var key = $"{page}-{pageSize}";
+            var key = $"{filter?.Body}-{orderBy?.Body}-{descending}-{page}-{pageSize}";
             return await memoryCache.GetOrCreate(key, async e =>
             {
                 e.SetOptions(new MemoryCacheEntryOptions
                 {
-                    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1),
+                    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1),
                 });
                 return await repository.GetAllAsync(filter, orderBy, descending, page, pageSize);
             });
         }
 
         public async Task StoreAsync(T entity)
         {
+            memoryCache.Set(entity.Id, entity, TimeSpan.FromHours(1));
             await repository.StoreAsync(entity);
         }
 
         public async Task DeleteAsync(string id)
         {
+            memoryCache.Remove(id);
             await repository.DeleteAsync(id);
         }
     }

LinkDotNet.Blog.Infrastructure/Persistence/Sql/Repository.cs

@@ -20,7 +20,7 @@ public Repository(BlogDbContext blogDbContext)
 
         public async Task<TEntity> GetByIdAsync(string id)
         {
-            return await blogDbContext.Set<TEntity>().SingleOrDefaultAsync(b => b.Id == id);
+            return await blogDbContext.Set<TEntity>().AsNoTracking().SingleOrDefaultAsync(b => b.Id == id);
         }
 
         public async Task<IPagedList<TEntity>> GetAllAsync(

LinkDotNet.Blog.UnitTests/Infrastructure/Persistence/CachedRepositoryTests.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using FluentAssertions;
+using LinkDotNet.Blog.Domain;
+using LinkDotNet.Blog.Infrastructure.Persistence;
+using LinkDotNet.Blog.TestUtilities;
+using Microsoft.Extensions.Caching.Memory;
+using Moq;
+using X.PagedList;
+using Xunit;
+
+namespace LinkDotNet.Blog.UnitTests.Infrastructure.Persistence
+{
+    public class CachedRepositoryTests
+    {
+        private readonly Mock<IRepository<BlogPost>> repositoryMock;
+        private readonly CachedRepository<BlogPost> sut;
+
+        public CachedRepositoryTests()
+        {
+            repositoryMock = new Mock<IRepository<BlogPost>>();
+            sut = new CachedRepository<BlogPost>(repositoryMock.Object, new MemoryCache(new MemoryCacheOptions()));
+        }
+
+        [Fact]
+        public async Task ShouldGetFromCacheWhenLoaded()
+        {
+            var blogPost = new BlogPostBuilder().Build();
+            repositoryMock.Setup(r => r.GetByIdAsync("id")).ReturnsAsync(blogPost);
+            var firstCall = await sut.GetByIdAsync("id");
+
+            var secondCall = await sut.GetByIdAsync("id");
+
+            firstCall.Should().Be(secondCall);
+            firstCall.Should().Be(blogPost);
+            repositoryMock.Verify(r => r.GetByIdAsync("id"), Times.Once);
+        }
+
+        [Fact]
+        public async Task ShouldGetAllFromCacheWhenLoaded()
+        {
+            var blogPost = new BlogPostBuilder().Build();
+            repositoryMock.Setup(r => r.GetAllAsync(
+                    It.IsAny<Expression<Func<BlogPost, bool>>>(),
+                    It.IsAny<Expression<Func<BlogPost, object>>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<int>(),
+                    It.IsAny<int>()))
+                .ReturnsAsync(new PagedList<BlogPost>(new[] { blogPost }, 1, 1));
+            var firstCall = await sut.GetAllAsync();
+
+            var secondCall = await sut.GetAllAsync();
+
+            firstCall.Count.Should().Be(1);
+            secondCall.Count.Should().Be(1);
+            repositoryMock.Verify(
+                r => r.GetAllAsync(
+                It.IsAny<Expression<Func<BlogPost, bool>>>(),
+                It.IsAny<Expression<Func<BlogPost, object>>>(),
+                It.IsAny<bool>(),
+                It.IsAny<int>(),
+                It.IsAny<int>()),
+                Times.Once);
+        }
+
+        [Fact]
+        public async Task ShouldNotCacheWhenParameterDifferent()
+        {
+            SetupRepository();
+            await sut.GetAllAsync();
+            await sut.GetAllAsync(p => p.IsPublished);
+            await sut.GetAllAsync(p => p.IsPublished, p => p.Likes);
+            await sut.GetAllAsync(
+                p => p.IsPublished,
+                p => p.Likes,
+                false);
+            await sut.GetAllAsync(
+                p => p.IsPublished,
+                p => p.Likes,
+                false,
+                2);
+            await sut.GetAllAsync(
+                p => p.IsPublished,
+                p => p.Likes,
+                false,
+                2,
+                30);
+
+            repositoryMock.Verify(
+                r => r.GetAllAsync(
+                    It.IsAny<Expression<Func<BlogPost, bool>>>(),
+                    It.IsAny<Expression<Func<BlogPost, object>>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<int>(),
+                    It.IsAny<int>()),
+                Times.Exactly(6));
+        }
+
+        [Fact]
+        public async Task ShouldUpdateCacheOnStore()
+        {
+            var blogPost = new BlogPostBuilder().Build();
+            blogPost.Id = "id";
+            repositoryMock.Setup(r => r.GetByIdAsync("id")).ReturnsAsync(blogPost);
+            await sut.GetByIdAsync("id");
+            var update = new BlogPostBuilder().WithTitle("new").Build();
+            blogPost.Update(update);
+            await sut.StoreAsync(blogPost);
+
+            var latest = await sut.GetByIdAsync("id");
+
+            latest.Title.Should().Be("new");
+        }
+
+        [Fact]
+        public async Task ShouldDelete()
+        {
+            await sut.DeleteAsync("id");
+
+            repositoryMock.Verify(r => r.DeleteAsync("id"), Times.Once);
+        }
+
+        private void SetupRepository()
+        {
+            var blogPost = new BlogPostBuilder().Build();
+            repositoryMock.Setup(r => r.GetAllAsync(
+                    It.IsAny<Expression<Func<BlogPost, bool>>>(),
+                    It.IsAny<Expression<Func<BlogPost, object>>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<int>(),
+                    It.IsAny<int>()))
+                .ReturnsAsync(new PagedList<BlogPost>(new[] { blogPost }, 1, 1));
+        }
+    }
+}

LinkDotNet.Blog.UnitTests/LinkDotNet.Blog.UnitTests.csproj

@@ -44,10 +44,6 @@
         <AdditionalFiles Include="..\stylecop.json" Link="stylecop.json" />
     </ItemGroup>
 
-    <ItemGroup>
-      <Folder Include="Infrastructure\Persistence" />
-    </ItemGroup>
-
     <ItemGroup>
       <Compile Remove="Web\Shared\Services\LocalStorageServiceTests.cs" />
     </ItemGroup>