CSHARP-2756: Implement CompressorConfiguration Equals method.

Author: rstam

src/MongoDB.Driver.Core/Core/Configuration/CompressorConfiguration.cs

@@ -15,6 +15,7 @@
 
 using System.Collections.Generic;
 using MongoDB.Driver.Core.Compression;
+using MongoDB.Shared;
 
 namespace MongoDB.Driver.Core.Configuration
 {
@@ -23,24 +24,90 @@ namespace MongoDB.Driver.Core.Configuration
     /// </summary>
     public sealed class CompressorConfiguration
     {
+        // private fields
+        private readonly IDictionary<string, object> _properties;
+        private readonly CompressorType _type;
+
+        // constructors
         /// <summary>
         /// Initializes an instance of <see cref="CompressorConfiguration"/>.
         /// </summary>
         /// <param name="type">The compressor type.</param>
         public CompressorConfiguration(CompressorType type)
         {
-            Type = type;
-            Properties = new Dictionary<string, object>();
+            _type = type;
+            _properties = new Dictionary<string, object>();
         }
 
+        // public properties
         /// <summary>
         /// Gets the compression properties.
         /// </summary>
-        public IDictionary<string, object> Properties { get; }
+        public IDictionary<string, object> Properties => _properties;
 
         /// <summary>
         /// Gets the compressor type.
         /// </summary>
-        public CompressorType Type { get; }
+        public CompressorType Type => _type;
+
+        // public methods
+        /// <inheritdoc/>
+        public override bool Equals(object obj)
+        {
+            if (object.ReferenceEquals(obj, this))
+            {
+                return true;
+            }
+
+            if (object.ReferenceEquals(obj, null) || obj.GetType() != typeof(CompressorConfiguration))
+            {
+                return false;
+            }
+
+            var rhs = (CompressorConfiguration)obj;
+            return
+                _type == rhs._type &&
+                IsEquivalentTo(_properties, rhs._properties);
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return new Hasher()
+                .Hash(_type)
+                .HashElements(_properties.Keys) // keep it cheap
+                .GetHashCode();
+        }
+
+        // private methods
+        private bool IsEquivalentTo(IDictionary<string, object> x, IDictionary<string, object> y)
+        {
+            if (object.ReferenceEquals(x, y))
+            {
+                return true;
+            }
+
+            if (object.ReferenceEquals(x, null) || object.ReferenceEquals(y, null))
+            {
+                return false;
+            }
+
+            if (x.Count != y.Count)
+            {
+                return false;
+            }
+
+            foreach (var keyValuePair in x)
+            {
+                var key = keyValuePair.Key;
+                var xValue = keyValuePair.Value;
+                if (!y.TryGetValue(key, out var yValue) || !object.Equals(xValue, yValue))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

tests/MongoDB.Driver.Core.Tests/Core/Configuration/CompressorConfigurationTests.cs

@@ -0,0 +1,106 @@
+/* Copyright 2019-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using FluentAssertions;
+using MongoDB.Driver.Core.Compression;
+using MongoDB.Driver.Core.Configuration;
+using Xunit;
+
+namespace MongoDB.Driver.Core.Tests.Core.Configuration
+{
+    public class CompressorConfigurationTests
+    {
+        [Theory]
+        [InlineData(CompressorType.Noop)]
+        [InlineData(CompressorType.Snappy)]
+        [InlineData(CompressorType.Zlib)]
+        public void constructor_should_initialize_instance(CompressorType type)
+        {
+            var subject = new CompressorConfiguration(type);
+
+            subject.Type.Should().Be(type);
+            subject.Properties.Should().NotBeNull();
+            subject.Properties.Count.Should().Be(0);
+        }
+
+        [Theory]
+        [InlineData("Properties")]
+        [InlineData("Type")]
+        public void Equals_should_return_false_if_any_field_is_not_equal(string fieldName)
+        {
+            var type = CompressorType.Snappy;
+            var key = "x";
+            var subject1 = new CompressorConfiguration(type);
+            subject1.Properties.Add(key, 1);
+            switch (fieldName)
+            {
+                case "Properties": key = "y"; break;
+                case "Type": type = CompressorType.Zlib; break;
+            }
+            var subject2 = new CompressorConfiguration(type);
+            subject2.Properties.Add(key, 1);
+
+            var result = subject1.Equals(subject2);
+            var hashCode1 = subject1.GetHashCode();
+            var hashCode2 = subject2.GetHashCode();
+
+            result.Should().BeFalse();
+            hashCode2.Should().NotBe(hashCode1);
+        }
+
+        [Fact]
+        public void Equals_should_return_false_if_obj_is_null()
+        {
+            var subject = new CompressorConfiguration(CompressorType.Noop);
+
+            var result = subject.Equals(null);
+
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Equals_should_return_false_if_obj_is_wrong_type()
+        {
+            var subject = new CompressorConfiguration(CompressorType.Noop);
+            var obj = new object();
+
+            var result = subject.Equals(new object());
+            var hashCode1 = subject.GetHashCode();
+            var hashCode2 = obj.GetHashCode();
+
+            result.Should().BeFalse();
+            hashCode2.Should().NotBe(hashCode1);
+        }
+
+        [Theory]
+        [InlineData(CompressorType.Noop)]
+        [InlineData(CompressorType.Snappy)]
+        [InlineData(CompressorType.Zlib)]
+        public void Equals_should_return_true_if_all_fields_are_equal(CompressorType type)
+        {
+            var subject1 = new CompressorConfiguration(type);
+            var subject2 = new CompressorConfiguration(type);
+            subject1.Properties.Add("x", 1);
+            subject2.Properties.Add("x", 1);
+
+            var result = subject1.Equals(subject2);
+            var hashCode1 = subject1.GetHashCode();
+            var hashCode2 = subject2.GetHashCode();
+
+            result.Should().BeTrue();
+            hashCode2.Should().Be(hashCode1);
+        }
+    }
+}