Fix equals.

Squidex · Jan 17, 2025 · b97d00d · b97d00d
1 parent 63e2a6f
commit b97d00d
Show file tree

Hide file tree

Showing 6 changed files with 134 additions and 22 deletions.
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -11,7 +11,7 @@
     <PackageProjectUrl>https://github.com/squidex/squidex</PackageProjectUrl>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-    <Version>6.26.0</Version>
+    <Version>6.27.0</Version>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

diff --git a/events/Squidex.Events.EntityFramework/FilterBuilder.cs b/events/Squidex.Events.EntityFramework/FilterBuilder.cs
@@ -60,7 +60,7 @@ public static IQueryable<EFEventCommit> ByPosition(this IQueryable<EFEventCommit
 
     public static IQueryable<EFEventCommit> ByStream(this IQueryable<EFEventCommit> q, StreamFilter filter)
     {
-        if (filter.Prefixes == null || filter.Prefixes.Length == 0)
+        if (filter.Prefixes == null || filter.Prefixes.Count == 0)
         {
             return q;
         }

diff --git a/events/Squidex.Events.GetEventStore/EventStoreProjectionClient.cs b/events/Squidex.Events.GetEventStore/EventStoreProjectionClient.cs
@@ -28,9 +28,9 @@ private string CreateFilterProjectionName(string filter)
     public async Task<string> CreateProjectionAsync(StreamFilter filter, bool waitForCompletion,
         CancellationToken ct)
     {
-        if (filter.Kind == StreamFilterKind.MatchFull && filter.Prefixes?.Length == 1)
+        if (filter.Kind == StreamFilterKind.MatchFull && filter.Prefixes?.Count == 1)
         {
-            return $"{prefix}-{filter.Prefixes[0]}";
+            return $"{prefix}-{filter.Prefixes.First()}";
         }
 
         var projectionRegex = filter.ToRegex();

diff --git a/events/Squidex.Events.GetEventStore/Extensions.cs b/events/Squidex.Events.GetEventStore/Extensions.cs
@@ -93,7 +93,7 @@ public static async IAsyncEnumerable<StoredEvent> IgnoreNotFound(this IAsyncEnum
 
     public static string ToRegex(this StreamFilter filter)
     {
-        if (filter.Prefixes == null || filter.Prefixes.Length == 0)
+        if (filter.Prefixes == null || filter.Prefixes.Count == 0)
         {
             return ".*";
         }

diff --git a/events/Squidex.Events.Tests/StreamFilterTests.cs b/events/Squidex.Events.Tests/StreamFilterTests.cs
@@ -20,10 +20,82 @@ public void Should_simplify_input_to_default_filter()
     }
 
     [Fact]
-    public void Should_simplify_input_to_default_filter_with_factory()
+    public void Should_create_empty_full_filter()
     {
         var sut = StreamFilter.Name();
 
-        Assert.Equal(default, sut);
+        Assert.Equal(StreamFilterKind.MatchFull, sut.Kind);
+        Assert.Empty(sut.Prefixes!.ToArray());
+    }
+
+    [Fact]
+    public void Should_create_full_filter()
+    {
+        var sut = StreamFilter.Name("a", "b", "c");
+
+        Assert.Equal(StreamFilterKind.MatchFull, sut.Kind);
+        Assert.Equal(new[] { "a", "b", "c" }, sut.Prefixes!.ToArray());
+    }
+
+    [Fact]
+    public void Should_create_empty_prefix_filter()
+    {
+        var sut = StreamFilter.Name();
+
+        Assert.Equal(StreamFilterKind.MatchFull, sut.Kind);
+        Assert.Empty(sut.Prefixes!.ToArray());
+    }
+
+    [Fact]
+    public void Should_create_prefix_filter()
+    {
+        var sut = StreamFilter.Prefix("a", "b", "c");
+
+        Assert.Equal(StreamFilterKind.MatchStart, sut.Kind);
+        Assert.Equal(new[] { "a", "b", "c" }, sut.Prefixes!.ToArray());
+    }
+
+    [Fact]
+    public void Should_implement_equals()
+    {
+        var prefix1 = StreamFilter.Prefix("a", "b", "c");
+        var prefix2 = StreamFilter.Prefix("a", "b", "c");
+        var prefix3 = StreamFilter.Prefix("c", "a", "b");
+        var prefix4 = StreamFilter.Prefix("a", "b", "c", "d");
+        var prefix5 = StreamFilter.Prefix();
+        var prefix6 = new StreamFilter(StreamFilterKind.MatchStart);
+
+        var name1 = StreamFilter.Name("a", "b", "c");
+        var name2 = StreamFilter.Name("a", "b", "c");
+        var name3 = StreamFilter.Name("c", "a", "b");
+        var name4 = StreamFilter.Name("a", "b", "c", "d");
+        var name5 = StreamFilter.Name();
+        var name6 = new StreamFilter(StreamFilterKind.MatchFull);
+
+        static void AssertEqual(StreamFilter lhs, StreamFilter rhs)
+        {
+            Assert.Equal(lhs, rhs);
+            Assert.Equal(lhs.GetHashCode(), rhs.GetHashCode());
+            Assert.True(lhs == rhs);
+        }
+
+        static void AssertNotEqual(StreamFilter lhs, StreamFilter rhs)
+        {
+            Assert.NotEqual(lhs, rhs);
+            Assert.NotEqual(lhs.GetHashCode(), rhs.GetHashCode());
+            Assert.True(lhs != rhs);
+        }
+
+        AssertEqual(prefix1, prefix2);
+        AssertEqual(prefix1, prefix3);
+        AssertEqual(prefix5, prefix6);
+        AssertNotEqual(prefix2, prefix4);
+
+        AssertEqual(name1, name2);
+        AssertEqual(name1, name3);
+        AssertEqual(name5, name6);
+        AssertNotEqual(name2, name4);
+
+        AssertNotEqual(prefix1, name1);
     }
 }
diff --git a/events/Squidex.Events/StreamFilter.cs b/events/Squidex.Events/StreamFilter.cs
@@ -9,36 +9,76 @@
 
 namespace Squidex.Events;
 
-public readonly record struct StreamFilter
+public readonly struct StreamFilter(StreamFilterKind kind, IReadOnlySet<string>? prefixes = null) : IEquatable<StreamFilter>
 {
-    public string[]? Prefixes { get; }
+    public IReadOnlySet<string>? Prefixes { get; } = prefixes;
 
-    public StreamFilterKind Kind { get; }
-
-    public StreamFilter(StreamFilterKind kind, params string[] prefixes)
-    {
-        Kind = kind;
-
-        if (prefixes.Length > 0)
-        {
-            Prefixes = prefixes;
-        }
-    }
+    public StreamFilterKind Kind { get; } = kind;
 
     public static StreamFilter Prefix(params string[] prefixes)
     {
-        return new StreamFilter(StreamFilterKind.MatchStart, prefixes);
+        return new StreamFilter(StreamFilterKind.MatchStart, prefixes?.ToHashSet());
     }
 
     public static StreamFilter Name(params string[] prefixes)
     {
-        return new StreamFilter(StreamFilterKind.MatchFull, prefixes);
+        return new StreamFilter(StreamFilterKind.MatchFull, prefixes?.ToHashSet());
     }
 
     public static StreamFilter All()
     {
         return default;
     }
+
+    public static bool operator ==(StreamFilter lhs, StreamFilter rhs)
+    {
+        return lhs.Equals(rhs);
+    }
+
+    public static bool operator !=(StreamFilter lhs, StreamFilter rhs)
+    {
+        return !lhs.Equals(rhs);
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is StreamFilter other && Equals(other);
+    }
+
+    public bool Equals(StreamFilter other)
+    {
+        if (Kind != other.Kind)
+        {
+            return false;
+        }
+
+        if ((Prefixes == null || Prefixes.Count == 0) && (other.Prefixes == null || other.Prefixes.Count == 0))
+        {
+            return true;
+        }
+
+        if (Prefixes == null || other.Prefixes == null)
+        {
+            return false;
+        }
+
+        return Prefixes?.SetEquals(other.Prefixes) == true;
+    }
+
+    public override int GetHashCode()
+    {
+        var hashCode = 17 * Kind.GetHashCode();
+
+        if (Prefixes != null)
+        {
+            foreach (var prefix in Prefixes)
+            {
+                hashCode ^= 23 * prefix.GetHashCode(StringComparison.Ordinal);
+            }
+        }
+
+        return hashCode;
+    }
 }
 
 public enum StreamFilterKind