Improve tests

backend/src/Squidex.Domain.Apps.Entities/Assets/AssetUsageTracker_EventHandling.cs

@@ -107,6 +107,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
             foreach (var @event in events)
             {
                 var typedEvent = (AssetEvent)@event.Payload;
+
                 var appId = typedEvent.AppId.Id;
                 var assetId = typedEvent.AssetId;
                 var assetKey = @event.Headers.AggregateId();

backend/src/Squidex.Domain.Apps.Entities/Assets/BackupAssets.cs

@@ -119,37 +119,33 @@ namespace Squidex.Domain.Apps.Entities.Assets
         private async Task RestoreTagsAsync(RestoreContext context,
             CancellationToken ct)
         {
-            var tags = (Dictionary<string, Tag>?)null;
+            var export = new TagsExport();
 
             if (await context.Reader.HasFileAsync(TagsFile, ct))
             {
-                tags = await context.Reader.ReadJsonAsync<Dictionary<string, Tag>>(TagsFile, ct);
+                export.Tags = await context.Reader.ReadJsonAsync<Dictionary<string, Tag>>(TagsFile, ct);
             }
 
-            var alias = (Dictionary<string, string>?)null;
-
             // For backwards compabibility we store the tags and the aliases in different locations.
             if (await context.Reader.HasFileAsync(TagsAliasFile, ct))
             {
-                alias = await context.Reader.ReadJsonAsync<Dictionary<string, string>>(TagsAliasFile, ct);
+                export.Alias = await context.Reader.ReadJsonAsync<Dictionary<string, string>>(TagsAliasFile, ct);
             }
 
-            if (alias == null && tags == null)
+            if (export.Alias == null && export.Tags == null)
             {
                 return;
             }
 
-            if (tags != null)
+            if (export.Tags != null)
             {
                 // Import the tags without count, because they will populated later by the event processor.
-                foreach (var (_, tag) in tags)
+                foreach (var (_, tag) in export.Tags)
                 {
                     tag.Count = 0;
                 }
             }
 
-            var export = new TagsExport { Tags = tags!, Alias = alias! };
-
             await tagService.RebuildTagsAsync(context.AppId, TagGroups.Assets, export, ct);
         }
 

backend/src/Squidex.Domain.Apps.Entities/Tags/TagService.cs

@@ -35,30 +35,33 @@ namespace Squidex.Domain.Apps.Entities.Tags
                 return default;
             }
 
-            public bool Clear()
+            public bool Rebuild(TagsExport export)
             {
-                var isChanged = false;
-
-                foreach (var (_, tag) in Tags)
+                if (export.Tags != null)
                 {
-                    isChanged = tag.Count > 0;
+                    Tags = export.Tags;
+                }
 
-                    tag.Count = 0;
+                if (export.Alias != null)
+                {
+                    Alias = export.Alias;
                 }
 
-                return isChanged;
+                return true;
             }
 
-            public bool Rebuild(TagsExport export)
+            public bool Clear()
             {
-                Tags = export.Tags;
+                var isChanged = false;
 
-                if (Alias.EqualsDictionary(export.Alias))
+                foreach (var (_, tag) in Tags)
                 {
-                    Alias = export.Alias;
+                    isChanged = tag.Count > 0;
+
+                    tag.Count = 0;
                 }
 
-                return true;
+                return isChanged;
             }
 
             public bool Rename(string name, string newName)
@@ -105,6 +108,7 @@ namespace Squidex.Domain.Apps.Entities.Tags
                         if (newCount != tag.Count)
                         {
                             tag.Count = newCount;
+
                             isChanged = true;
                         }
                     }

backend/tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetUsageTrackerTests.cs

@@ -33,6 +33,9 @@ namespace Squidex.Domain.Apps.Entities.Assets
         {
             assetKey = DomainId.Combine(appId, assetId);
 
+            A.CallTo(() => usageTracker.FallbackCategory)
+                .Returns("*");
+
             sut = new AssetUsageTracker(usageTracker, assetLoader, tagService, store);
         }
 

backend/tests/Squidex.Domain.Apps.Entities.Tests/Assets/BackupAssetsTests.cs

@@ -10,6 +10,7 @@ using Squidex.Assets;
 using Squidex.Domain.Apps.Core.Tags;
 using Squidex.Domain.Apps.Entities.Assets.DomainObject;
 using Squidex.Domain.Apps.Entities.Backup;
+using Squidex.Domain.Apps.Events.Apps;
 using Squidex.Domain.Apps.Events.Assets;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
@@ -97,13 +98,19 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             var context = CreateRestoreContext();
 
+            var envelope =
+                new Envelope<IEvent>(new AppCreated
+                {
+                    AppId = appId
+                });
+
             A.CallTo(() => context.Reader.HasFileAsync(A<string>._, ct))
                 .Returns(true);
 
             A.CallTo(() => context.Reader.ReadJsonAsync<Dictionary<string, Tag>>(A<string>._, ct))
                 .Returns(tags);
 
-            await sut.RestoreAsync(context, ct);
+            await sut.RestoreEventAsync(envelope, context, ct);
 
             A.CallTo(() => tagService.RebuildTagsAsync(appId.Id, TagGroups.Assets, A<TagsExport>.That.Matches(x => x.Tags == tags), ct))
                 .MustHaveHappened();
@@ -116,13 +123,19 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             var context = CreateRestoreContext();
 
+            var envelope =
+                new Envelope<IEvent>(new AppCreated
+                {
+                    AppId = appId
+                });
+
             A.CallTo(() => context.Reader.HasFileAsync(A<string>._, ct))
                 .Returns(false).Once().Then.Returns(true);
 
             A.CallTo(() => context.Reader.ReadJsonAsync<Dictionary<string, string>>(A<string>._, ct))
                 .Returns(alias);
 
-            await sut.RestoreAsync(context, ct);
+            await sut.RestoreEventAsync(envelope, context, ct);
 
             A.CallTo(() => tagService.RebuildTagsAsync(appId.Id, TagGroups.Assets, A<TagsExport>.That.Matches(x => x.Alias == alias), ct))
                 .MustHaveHappened();
@@ -135,13 +148,19 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
             var context = CreateRestoreContext();
 
+            var envelope =
+                new Envelope<IEvent>(new AppCreated
+                {
+                    AppId = appId
+                });
+
             A.CallTo(() => context.Reader.HasFileAsync(A<string>._, ct))
                 .Returns(false);
 
             A.CallTo(() => context.Reader.ReadJsonAsync<Dictionary<string, string>>(A<string>._, ct))
                 .Returns(alias);
 
-            await sut.RestoreAsync(context, ct);
+            await sut.RestoreEventAsync(envelope, context, ct);
 
             A.CallTo(() => context.Reader.ReadJsonAsync<Dictionary<string, string>>(A<string>._, A<CancellationToken>._))
                 .MustNotHaveHappened();

backend/tests/Squidex.Domain.Apps.Entities.Tests/Tags/TagServiceTests.cs

@@ -135,7 +135,8 @@ namespace Squidex.Domain.Apps.Entities.Tags
                     ["id1"] = new Tag { Name = "tag1", Count = 1 },
                     ["id2"] = new Tag { Name = "tag2", Count = 2 },
                     ["id3"] = new Tag { Name = "tag3", Count = 6 }
-                }
+                },
+                Alias = null!
             };
 
             await sut.RebuildTagsAsync(appId, group, tags, ct);
@@ -151,7 +152,28 @@ namespace Squidex.Domain.Apps.Entities.Tags
 
             var export = await sut.GetExportableTagsAsync(appId, group, ct);
 
-            export.Should().BeEquivalentTo(tags);
+            Assert.Equal(tags.Tags, export.Tags);
+            Assert.Empty(export.Alias);
+        }
+
+        [Fact]
+        public async Task Should_rebuild_with_broken_export()
+        {
+            var tags = new TagsExport
+            {
+                Alias = new Dictionary<string, string>
+                {
+                    ["id1"] = "id2"
+                },
+                Tags = null!
+            };
+
+            await sut.RebuildTagsAsync(appId, group, tags, ct);
+
+            var export = await sut.GetExportableTagsAsync(appId, group, ct);
+
+            Assert.Equal(tags.Alias, export.Alias);
+            Assert.Empty(export.Tags);
         }
 
         [Fact]