IEnumerableSerializerBaseTests.cs

/* Copyright 2010-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 System.Collections.Generic;
using FluentAssertions;
using MongoDB.Bson;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
using MongoDB.Bson.Serialization.Serializers;
using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
using Xunit;

namespace MongoDB.Driver.Tests.Linq.Linq3Implementation.Serializers
{
    public class IEnumerableSerializerBaseTests
    {
        [Fact]
        public void Equals_derived_should_return_false()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);
            var y = new DerivedFromConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);

            var result = x.Equals(y);

            result.Should().Be(false);
        }

        [Fact]
        public void Equals_null_should_return_false()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);

            var result = x.Equals(null);

            result.Should().Be(false);
        }

        [Fact]
        public void Equals_object_should_return_false()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);
            var y = new object();

            var result = x.Equals(y);

            result.Should().Be(false);
        }

        [Fact]
        public void Equals_self_should_return_true()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);

            var result = x.Equals(x);

            result.Should().Be(true);
        }

        [Fact]
        public void Equals_with_equal_fields_should_return_true()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);
            var y = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);

            var result = x.Equals(y);

            result.Should().Be(true);
        }

        [Fact]
        public void Equals_with_not_equal_field_should_return_false()
        {
            var itemSerializer1 = new Int32Serializer(BsonType.Int32);
            var itemSerializer2 = new Int32Serializer(BsonType.String);
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(itemSerializer1);
            var y = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(itemSerializer2);

            var result = x.Equals(y);

            result.Should().Be(false);
        }

        [Fact]
        public void GetHashCode_should_return_zero()
        {
            var x = (IEnumerableSerializerBase<IEnumerable<int>, int>)new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);

            var result = x.GetHashCode();

            result.Should().Be(0);
        }

        [Fact]
        public void Serialize_null_should_write_null()
        {
            var serializer = new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);
            var document = new BsonDocument();
            using var writer = new BsonDocumentWriter(document);
            var context = BsonSerializationContext.CreateRoot(writer);
            writer.WriteStartDocument();
            writer.WriteName("x");

            serializer.Serialize(context, new BsonSerializationArgs(), null);

            writer.WriteEndDocument();
            document["x"].Should().Be(BsonNull.Value);
        }

        [Fact]
        public void Deserialize_null_should_return_default()
        {
            var serializer = new ConcreteIEnumerableSerializerBase<IEnumerable<int>, int>(Int32Serializer.Instance);
            var document = new BsonDocument("x", BsonNull.Value);
            using var reader = new BsonDocumentReader(document);
            reader.ReadStartDocument();
            reader.ReadName("x");
            var context = BsonDeserializationContext.CreateRoot(reader);

            var result = serializer.Deserialize(context, new BsonDeserializationArgs { NominalType = typeof(IEnumerable<int>) });

            result.Should().BeNull();
        }

        internal class ConcreteIEnumerableSerializerBase<TEnumerable, TItem> : IEnumerableSerializerBase<TEnumerable, TItem>
            where TEnumerable : IEnumerable<TItem>
        {
            public ConcreteIEnumerableSerializerBase(IBsonSerializer<TItem> itemSerializer) : base(itemSerializer)
            {
            }

            protected override TEnumerable CreateDeserializedValue(List<TItem> items) => throw new System.NotImplementedException();
        }

        internal class DerivedFromConcreteIEnumerableSerializerBase<TEnumerable, TItem> : ConcreteIEnumerableSerializerBase<TEnumerable, TItem>
            where TEnumerable : IEnumerable<TItem>
        {
            public DerivedFromConcreteIEnumerableSerializerBase(IBsonSerializer<TItem> itemSerializer) : base(itemSerializer)
            {
            }
        }
    }
}