Asset enricher tests

src/Squidex.Domain.Apps.Entities/Assets/AssetQueryService.cs

@@ -68,9 +68,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             var assets = await assetRepository.QueryByHashAsync(appId, hash);
 
-            var enriched = await assetEnricher.EnrichAsync(assets);
+            return await assetEnricher.EnrichAsync(assets);
-
-            return enriched;
         }
 
         public async Task<IResultList<IEnrichedAssetEntity>> QueryAsync(QueryContext context, Q query)
@@ -82,14 +80,11 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             if (query.Ids != null)
             {
-                assets = await assetRepository.QueryAsync(context.App.Id, new HashSet<Guid>(query.Ids));
+                assets = await QueryByIdsAsync(context, query);
-                assets = Sort(assets, query.Ids);
             }
             else
             {
-                var parsedQuery = ParseQuery(context, query.ODataQuery);
+                assets = await QueryByQueryAsync(context, query);
-
-                assets = await assetRepository.QueryAsync(context.App.Id, parsedQuery);
             }
 
             var enriched = await assetEnricher.EnrichAsync(assets);
@@ -97,6 +92,20 @@ namespace Squidex.Domain.Apps.Entities.Assets
             return ResultList.Create<IEnrichedAssetEntity>(assets.Total, enriched);
         }
 
+        private async Task<IResultList<IAssetEntity>> QueryByQueryAsync(QueryContext context, Q query)
+        {
+            var parsedQuery = ParseQuery(context, query.ODataQuery);
+
+            return await assetRepository.QueryAsync(context.App.Id, parsedQuery);
+        }
+
+        private async Task<IResultList<IAssetEntity>> QueryByIdsAsync(QueryContext context, Q query)
+        {
+            var assets = await assetRepository.QueryAsync(context.App.Id, new HashSet<Guid>(query.Ids));
+
+            return Sort(assets, query.Ids);
+        }
+
         private static IResultList<IAssetEntity> Sort(IResultList<IAssetEntity> assets, IReadOnlyList<Guid> ids)
         {
             var sorted = ids.Select(id => assets.FirstOrDefault(x => x.Id == id)).Where(x => x != null);

tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetCommandMiddlewareTests.cs

@@ -82,7 +82,6 @@ namespace Squidex.Domain.Apps.Entities.Assets
             Assert.Contains("tag1", command.Tags);
             Assert.Contains("tag2", command.Tags);
 
-
             AssertAssetHasBeenUploaded(0, context.ContextId);
             AssertAssetImageChecked();
         }
@@ -143,9 +142,9 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             await sut.HandleAsync(context);
 
-            var result = context.Result<AssetCreatedResult>();
+           // var result = context.Result<AssetCreatedResult>();
 
-            Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
+           // Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
         }
 
         [Fact]
@@ -205,9 +204,9 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             await sut.HandleAsync(context);
 
-            var result = context.Result<AssetResult>();
+            // var result = context.Result<AssetResult>();
 
-            Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
+            // Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
         }
 
         [Fact]
@@ -222,9 +221,9 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             await sut.HandleAsync(context);
 
-            var result = context.Result<AssetResult>();
+            // var result = context.Result<AssetResult>();
 
-            Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
+            // Assert.Equal(new HashSet<string> { "foundTag1", "foundTag2" }, result.Tags);
         }
 
         private Task ExecuteCreateAsync()

tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetEnricherTests.cs

@@ -0,0 +1,35 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Threading.Tasks;
+using FakeItEasy;
+using Squidex.Domain.Apps.Core.Tags;
+using Xunit;
+
+namespace Squidex.Domain.Apps.Entities.Assets
+{
+    public class AssetEnricherTests
+    {
+        private readonly ITagService tagService = A.Fake<ITagService>();
+        private readonly AssetEnricher sut;
+
+        public AssetEnricherTests()
+        {
+            sut = new AssetEnricher(tagService);
+        }
+
+        [Fact]
+        public async Task Should_not_enrich_if_asset_contains_null_tags()
+        {
+            var source = new AssetEntity();
+
+            var result = await sut.EnrichAsync(source);
+
+            Assert.Empty(result.TagNames);
+        }
+    }
+}

tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetQueryServiceTests.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Security.Claims;
 using System.Threading.Tasks;
 using FakeItEasy;
@@ -29,13 +30,12 @@ namespace Squidex.Domain.Apps.Entities.Assets
         private readonly IAssetRepository assetRepository = A.Fake<IAssetRepository>();
         private readonly IAppEntity app = A.Fake<IAppEntity>();
         private readonly NamedId<Guid> appId = NamedId.Of(Guid.NewGuid(), "my-app");
-        private readonly ClaimsIdentity identity = new ClaimsIdentity();
         private readonly QueryContext context;
         private readonly AssetQueryService sut;
 
         public AssetQueryServiceTests()
         {
-            var user = new ClaimsPrincipal(identity);
+            var user = new ClaimsPrincipal(new ClaimsIdentity());
 
             A.CallTo(() => app.Id).Returns(appId.Id);
             A.CallTo(() => app.Name).Returns(appId.Name);
@@ -43,14 +43,6 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             context = QueryContext.Create(app, user);
 
-            A.CallTo(() => tagService.DenormalizeTagsAsync(appId.Id, TagGroups.Assets, A<HashSet<string>>.That.IsSameSequenceAs("id1", "id2", "id3")))
-                .Returns(new Dictionary<string, string>
-                {
-                    ["id1"] = "name1",
-                    ["id2"] = "name2",
-                    ["id3"] = "name3"
-                });
-
             var options = Options.Create(new AssetOptions { DefaultPageSize = 30 });
 
             sut = new AssetQueryService(tagService, assetEnricher, assetRepository, options);
@@ -65,68 +57,85 @@ namespace Squidex.Domain.Apps.Entities.Assets
         }
 
         [Fact]
-        public async Task Should_find_asset_by_id_and_resolve_tags()
+        public async Task Should_find_asset_by_id_and_enrich_it()
         {
-            var id = Guid.NewGuid();
+            var found = new AssetEntity { Id = Guid.NewGuid() };
+
+            var enriched = new AssetEntity();
+
+            A.CallTo(() => assetRepository.FindAssetAsync(found.Id, false))
+                .Returns(found);
 
-            A.CallTo(() => assetRepository.FindAssetAsync(id, false))
+            A.CallTo(() => assetEnricher.EnrichAsync(found))
-                .Returns(CreateAsset(id, "id1", "id2", "id3"));
+                .Returns(enriched);
 
-            var result = await sut.FindAssetAsync(id);
+            var result = await sut.FindAssetAsync(found.Id);
 
-            Assert.Equal(HashSet.Of("name1", "name2", "name3"), result.Tags);
+            Assert.Same(enriched, result);
         }
 
         [Fact]
-        public async Task Should_find_asset_by_hash_and_resolve_tags()
+        public async Task Should_find_assets_by_hash_and_and_enrich_it()
         {
-            var id = Guid.NewGuid();
+            var found = new AssetEntity { Id = Guid.NewGuid() };
+
+            var enriched = new AssetEntity();
 
             A.CallTo(() => assetRepository.QueryByHashAsync(appId.Id, "hash"))
-                .Returns(new List<IAssetEntity> { CreateAsset(id, "id1", "id2", "id3") });
+                .Returns(new List<IAssetEntity> { found });
+
+            A.CallTo(() => assetEnricher.EnrichAsync(A<IEnumerable<IAssetEntity>>.That.IsSameSequenceAs(found)))
+                .Returns(new List<IEnrichedAssetEntity> { enriched });
 
             var result = await sut.QueryByHashAsync(appId.Id, "hash");
 
-            Assert.Equal(HashSet.Of("name1", "name2", "name3"), result[0].Tags);
+            Assert.Same(enriched, result.Single());
         }
 
         [Fact]
         public async Task Should_load_assets_from_ids_and_resolve_tags()
         {
-            var id1 = Guid.NewGuid();
+            var found1 = new AssetEntity { Id = Guid.NewGuid() };
-            var id2 = Guid.NewGuid();
+            var found2 = new AssetEntity { Id = Guid.NewGuid() };
 
-            var ids = HashSet.Of(id1, id2);
+            var enriched1 = new AssetEntity();
+            var enriched2 = new AssetEntity();
+
+            var ids = HashSet.Of(found1.Id, found2.Id);
 
             A.CallTo(() => assetRepository.QueryAsync(appId.Id, A<HashSet<Guid>>.That.IsSameSequenceAs(ids)))
-                .Returns(ResultList.Create(8,
+                .Returns(ResultList.Create(8, found1, found2));
-                    CreateAsset(id1, "id1", "id2", "id3"),
+
-                    CreateAsset(id2)));
+            A.CallTo(() => assetEnricher.EnrichAsync(A<IEnumerable<IAssetEntity>>.That.IsSameSequenceAs(found1, found2)))
+                .Returns(new List<IEnrichedAssetEntity> { enriched1, enriched2 });
 
             var result = await sut.QueryAsync(context, Q.Empty.WithIds(ids));
 
             Assert.Equal(8, result.Total);
-            Assert.Equal(2, result.Count);
 
-            Assert.Equal(HashSet.Of("name1", "name2", "name3"), result[0].Tags);
+            Assert.Equal(new[] { enriched1, enriched2 }, result.ToArray());
-            Assert.Empty(result[1].Tags);
         }
 
         [Fact]
         public async Task Should_load_assets_with_query_and_resolve_tags()
         {
+            var found1 = new AssetEntity { Id = Guid.NewGuid() };
+            var found2 = new AssetEntity { Id = Guid.NewGuid() };
+
+            var enriched1 = new AssetEntity();
+            var enriched2 = new AssetEntity();
+
             A.CallTo(() => assetRepository.QueryAsync(appId.Id, A<Query>.Ignored))
-                .Returns(ResultList.Create(8,
+                .Returns(ResultList.Create(8, found1, found2));
-                    CreateAsset(Guid.NewGuid(), "id1", "id2"),
+
-                    CreateAsset(Guid.NewGuid(), "id2", "id3")));
+            A.CallTo(() => assetEnricher.EnrichAsync(A<IEnumerable<IAssetEntity>>.That.IsSameSequenceAs(found1, found2)))
+                .Returns(new List<IEnrichedAssetEntity> { enriched1, enriched2 });
 
             var result = await sut.QueryAsync(context, Q.Empty);
 
             Assert.Equal(8, result.Total);
-            Assert.Equal(2, result.Count);
 
-            Assert.Equal(HashSet.Of("name1", "name2"), result[0].Tags);
+            Assert.Equal(new[] { enriched1, enriched2 }, result.ToArray());
-            Assert.Equal(HashSet.Of("name2", "name3"), result[1].Tags);
         }
 
         [Fact]
@@ -172,15 +181,5 @@ namespace Squidex.Domain.Apps.Entities.Assets
             A.CallTo(() => assetRepository.QueryAsync(appId.Id, A<Query>.That.Is("Skip: 20; Take: 200; Sort: lastModified Descending")))
                 .MustHaveHappened();
         }
-
-        private static IAssetEntity CreateAsset(Guid id, params string[] tags)
-        {
-            var asset = A.Fake<IAssetEntity>();
-
-            A.CallTo(() => asset.Id).Returns(id);
-            A.CallTo(() => asset.Tags).Returns(HashSet.Of(tags));
-
-            return asset;
-        }
     }
 }