From ed960c802745e326d08fd806861c86b1357e52f1 Mon Sep 17 00:00:00 2001
From: Sebastian <sebastian@squidex.io>
Date: Sat, 21 Jul 2018 20:04:16 +0200
Subject: [PATCH] More tests with states stores.

---
 .../Backup/CleanerGrain.cs                    |  8 +++---
 .../Rules/Indexes/RulesByAppIndexGrain.cs     | 10 +++----
 .../Schemas/Indexes/SchemasByAppIndexGrain.cs | 10 +++----
 src/Squidex.Infrastructure/States/IStore.cs   |  2 +-
 src/Squidex.Infrastructure/States/Store.cs    |  2 +-
 .../States/PersistenceEventSourcingTests.cs   | 28 +++++++++++++++++++
 .../States/PersistenceSnapshotTests.cs        | 26 +++++++++++++++++
 7 files changed, 70 insertions(+), 16 deletions(-)

diff --git a/src/Squidex.Domain.Apps.Entities/Backup/CleanerGrain.cs b/src/Squidex.Domain.Apps.Entities/Backup/CleanerGrain.cs
index 8eb19922f..bd6b4c757 100644
--- a/src/Squidex.Domain.Apps.Entities/Backup/CleanerGrain.cs
+++ b/src/Squidex.Domain.Apps.Entities/Backup/CleanerGrain.cs
@@ -126,14 +126,14 @@ namespace Squidex.Domain.Apps.Entities.Backup
 
             foreach (var ruleId in ruleIds)
             {
-                await store.ClearSnapshotAsync<RuleState>(ruleId);
+                await store.RemoveSnapshotAsync<RuleState>(ruleId);
             }
 
             var schemaIds = await grainFactory.GetGrain<ISchemasByAppIndex>(appId).GetSchemaIdsAsync();
 
             foreach (var schemaId in schemaIds)
             {
-                await store.ClearSnapshotAsync<SchemaState>(schemaId);
+                await store.RemoveSnapshotAsync<SchemaState>(schemaId);
             }
 
             foreach (var storage in storages)
@@ -141,12 +141,12 @@ namespace Squidex.Domain.Apps.Entities.Backup
                 await storage.ClearAsync(appId);
             }
 
-            await store.ClearSnapshotAsync<AppState>(appId);
+            await store.RemoveSnapshotAsync<AppState>(appId);
         }
 
         private async Task DeleteAsync<TState>(Guid id)
         {
-            await store.ClearSnapshotAsync<TState>(id);
+            await store.RemoveSnapshotAsync<TState>(id);
         }
     }
 }
diff --git a/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesByAppIndexGrain.cs b/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesByAppIndexGrain.cs
index 6d72c92d2..23be15dfa 100644
--- a/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesByAppIndexGrain.cs
+++ b/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesByAppIndexGrain.cs
@@ -65,16 +65,16 @@ namespace Squidex.Domain.Apps.Entities.Rules.Indexes
             return persistence.WriteSnapshotAsync(state);
         }
 
-        public Task<List<Guid>> GetRuleIdsAsync()
-        {
-            return Task.FromResult(state.Rules.ToList());
-        }
-
         public Task ClearAsync()
         {
             state = new State();
 
             return persistence.DeleteAsync();
         }
+
+        public Task<List<Guid>> GetRuleIdsAsync()
+        {
+            return Task.FromResult(state.Rules.ToList());
+        }
     }
 }
diff --git a/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasByAppIndexGrain.cs b/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasByAppIndexGrain.cs
index 57b743957..dc2fc69c6 100644
--- a/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasByAppIndexGrain.cs
+++ b/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasByAppIndexGrain.cs
@@ -72,16 +72,16 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
             return Task.FromResult(schemaId);
         }
 
-        public Task<List<Guid>> GetSchemaIdsAsync()
-        {
-            return Task.FromResult(state.Schemas.Values.ToList());
-        }
-
         public Task ClearAsync()
         {
             state = new State();
 
             return persistence.DeleteAsync();
         }
+
+        public Task<List<Guid>> GetSchemaIdsAsync()
+        {
+            return Task.FromResult(state.Schemas.Values.ToList());
+        }
     }
 }
diff --git a/src/Squidex.Infrastructure/States/IStore.cs b/src/Squidex.Infrastructure/States/IStore.cs
index 8dee5d085..f8aa2cddd 100644
--- a/src/Squidex.Infrastructure/States/IStore.cs
+++ b/src/Squidex.Infrastructure/States/IStore.cs
@@ -23,6 +23,6 @@ namespace Squidex.Infrastructure.States
 
         Task ClearSnapshotsAsync<TState>();
 
-        Task ClearSnapshotAsync<TState>(TKey key);
+        Task RemoveSnapshotAsync<TState>(TKey key);
     }
 }
diff --git a/src/Squidex.Infrastructure/States/Store.cs b/src/Squidex.Infrastructure/States/Store.cs
index 6f693c5a2..3bbacc36d 100644
--- a/src/Squidex.Infrastructure/States/Store.cs
+++ b/src/Squidex.Infrastructure/States/Store.cs
@@ -63,7 +63,7 @@ namespace Squidex.Infrastructure.States
             return GetSnapshotStore<TState>().ClearAsync();
         }
 
-        public Task ClearSnapshotAsync<TState>(TKey key)
+        public Task RemoveSnapshotAsync<TState>(TKey key)
         {
             return GetSnapshotStore<TState>().RemoveAsync(key);
         }
diff --git a/tests/Squidex.Infrastructure.Tests/States/PersistenceEventSourcingTests.cs b/tests/Squidex.Infrastructure.Tests/States/PersistenceEventSourcingTests.cs
index a910af1bf..3b23fb421 100644
--- a/tests/Squidex.Infrastructure.Tests/States/PersistenceEventSourcingTests.cs
+++ b/tests/Squidex.Infrastructure.Tests/States/PersistenceEventSourcingTests.cs
@@ -205,6 +205,34 @@ namespace Squidex.Infrastructure.States
             await Assert.ThrowsAsync<DomainObjectVersionException>(() => persistence.WriteEventsAsync(new[] { new MyEvent(), new MyEvent() }.Select(Envelope.Create)));
         }
 
+        [Fact]
+        public async Task Should_delete_events_but_not_snapshot_when_deleted_snapshot_only()
+        {
+            var persistence = sut.WithEventSourcing<object, string>(key, x => { });
+
+            await persistence.DeleteAsync();
+
+            A.CallTo(() => eventStore.DeleteStreamAsync(key))
+                .MustHaveHappened();
+
+            A.CallTo(() => snapshotStore.RemoveAsync(key))
+                .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Should_delete_events_and_snapshot_when_deleted()
+        {
+            var persistence = sut.WithSnapshotsAndEventSourcing<object, object, string>(key, x => { }, x => { });
+
+            await persistence.DeleteAsync();
+
+            A.CallTo(() => eventStore.DeleteStreamAsync(key))
+                .MustHaveHappened();
+
+            A.CallTo(() => snapshotStore.RemoveAsync(key))
+                .MustHaveHappened();
+        }
+
         private void SetupEventStore(int count, int eventOffset = 0, int readPosition = 0)
         {
             SetupEventStore(Enumerable.Repeat(0, count).Select(x => new MyEvent()).ToArray(), eventOffset, readPosition);
diff --git a/tests/Squidex.Infrastructure.Tests/States/PersistenceSnapshotTests.cs b/tests/Squidex.Infrastructure.Tests/States/PersistenceSnapshotTests.cs
index b2e90f231..392f8efff 100644
--- a/tests/Squidex.Infrastructure.Tests/States/PersistenceSnapshotTests.cs
+++ b/tests/Squidex.Infrastructure.Tests/States/PersistenceSnapshotTests.cs
@@ -146,5 +146,31 @@ namespace Squidex.Infrastructure.States
 
             await Assert.ThrowsAsync<DomainObjectVersionException>(() => persistence.WriteSnapshotAsync(100));
         }
+
+        [Fact]
+        public async Task Should_delete_snapshot_but_not_events_when_deleted()
+        {
+            var persistence = sut.WithSnapshots<object, int, string>(key, x => { });
+
+            await persistence.DeleteAsync();
+
+            A.CallTo(() => eventStore.DeleteStreamAsync(A<string>.Ignored))
+                .MustNotHaveHappened();
+
+            A.CallTo(() => snapshotStore.RemoveAsync(key))
+                .MustHaveHappened();
+        }
+
+        [Fact]
+        public async Task Should_delete_snapshot_but_not_events_when_deleted_from_store()
+        {
+            await sut.RemoveSnapshotAsync<int>(key);
+
+            A.CallTo(() => eventStore.DeleteStreamAsync(A<string>.Ignored))
+                .MustNotHaveHappened();
+
+            A.CallTo(() => snapshotStore.RemoveAsync(key))
+                .MustHaveHappened();
+        }
     }
 }
\ No newline at end of file