diff --git a/src/MongoDB.Bson/Exceptions/BsonException.cs b/src/MongoDB.Bson/Exceptions/BsonException.cs index ca2db03a717..a8e6ea21121 100644 --- a/src/MongoDB.Bson/Exceptions/BsonException.cs +++ b/src/MongoDB.Bson/Exceptions/BsonException.cs @@ -66,6 +66,7 @@ public BsonException(string format, params object[] args) /// /// The SerializationInfo. /// The StreamingContext. + [Obsolete("Legacy serialization support APIs are obsolete: SYSLIB0051")] public BsonException(SerializationInfo info, StreamingContext context) : base(info, context) { diff --git a/src/MongoDB.Bson/Exceptions/BsonInternalException.cs b/src/MongoDB.Bson/Exceptions/BsonInternalException.cs index 150fc8f05f0..c0a0a665615 100644 --- a/src/MongoDB.Bson/Exceptions/BsonInternalException.cs +++ b/src/MongoDB.Bson/Exceptions/BsonInternalException.cs @@ -56,6 +56,7 @@ public BsonInternalException(string message, Exception innerException) /// /// The SerializationInfo. /// The StreamingContext. + [Obsolete("Legacy serialization support APIs are obsolete: SYSLIB0051")] public BsonInternalException(SerializationInfo info, StreamingContext context) : base(info, context) { diff --git a/src/MongoDB.Bson/Exceptions/BsonSerializationException.cs b/src/MongoDB.Bson/Exceptions/BsonSerializationException.cs index 4ac318ebe53..f64d9997659 100644 --- a/src/MongoDB.Bson/Exceptions/BsonSerializationException.cs +++ b/src/MongoDB.Bson/Exceptions/BsonSerializationException.cs @@ -56,6 +56,7 @@ public BsonSerializationException(string message, Exception innerException) /// /// The SerializationInfo. /// The StreamingContext. + [Obsolete("Legacy serialization support APIs are obsolete: SYSLIB0051")] public BsonSerializationException(SerializationInfo info, StreamingContext context) : base(info, context) { diff --git a/src/MongoDB.Bson/Exceptions/DuplicateBsonMemberMapAttributeException.cs b/src/MongoDB.Bson/Exceptions/DuplicateBsonMemberMapAttributeException.cs index caefa7ec10f..eb1df083179 100644 --- a/src/MongoDB.Bson/Exceptions/DuplicateBsonMemberMapAttributeException.cs +++ b/src/MongoDB.Bson/Exceptions/DuplicateBsonMemberMapAttributeException.cs @@ -48,6 +48,7 @@ public DuplicateBsonMemberMapAttributeException(string message, Exception inner) /// /// The info. /// The context. + [Obsolete("Legacy serialization support APIs are obsolete: SYSLIB0051")] protected DuplicateBsonMemberMapAttributeException(SerializationInfo info, StreamingContext context) : base(info, context) { diff --git a/src/MongoDB.Bson/Exceptions/TruncationException.cs b/src/MongoDB.Bson/Exceptions/TruncationException.cs index dcb6d1327ab..d455a0ce7e0 100644 --- a/src/MongoDB.Bson/Exceptions/TruncationException.cs +++ b/src/MongoDB.Bson/Exceptions/TruncationException.cs @@ -56,6 +56,7 @@ public TruncationException(string message, Exception innerException) /// /// The SerializationInfo. /// The StreamingContext. + [Obsolete("Legacy serialization support APIs are obsolete: SYSLIB0051")] public TruncationException(SerializationInfo info, StreamingContext context) : base(info, context) { diff --git a/src/MongoDB.Bson/Serialization/BsonDeserializationArgs.cs b/src/MongoDB.Bson/Serialization/BsonDeserializationArgs.cs index d9fb8b6c654..e210a598262 100644 --- a/src/MongoDB.Bson/Serialization/BsonDeserializationArgs.cs +++ b/src/MongoDB.Bson/Serialization/BsonDeserializationArgs.cs @@ -14,7 +14,6 @@ */ using System; -using MongoDB.Bson.IO; namespace MongoDB.Bson.Serialization { @@ -23,27 +22,9 @@ namespace MongoDB.Bson.Serialization /// public struct BsonDeserializationArgs { - // private fields - private Type _nominalType; - - // constructors - private BsonDeserializationArgs( - Type nominalType) - { - _nominalType = nominalType; - } - - // public properties /// /// Gets or sets the nominal type. /// - /// - /// The nominal type. - /// - public Type NominalType - { - get { return _nominalType; } - set { _nominalType = value; } - } + public Type NominalType { get; set; } } } diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationInfo.cs b/src/MongoDB.Bson/Serialization/BsonSerializationInfo.cs index 01a5b9315de..ff3237d9711 100644 --- a/src/MongoDB.Bson/Serialization/BsonSerializationInfo.cs +++ b/src/MongoDB.Bson/Serialization/BsonSerializationInfo.cs @@ -28,7 +28,7 @@ public class BsonSerializationInfo { #region static /// - /// Creates a new instance of the BsonSerializationinfo class with an element path instead of an element name. + /// Creates a new instance of the BsonSerializationInfo class with an element path instead of an element name. /// /// The element path. /// The serializer. diff --git a/src/MongoDB.Bson/Serialization/Serializers/NullableSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/NullableSerializer.cs index 8740bdd3a9b..bef79d7f2b2 100644 --- a/src/MongoDB.Bson/Serialization/Serializers/NullableSerializer.cs +++ b/src/MongoDB.Bson/Serialization/Serializers/NullableSerializer.cs @@ -40,6 +40,11 @@ public static class NullableSerializer /// A NullableSerializer public static IBsonSerializer Create(IBsonSerializer valueSerializer) { + if (valueSerializer == null) + { + throw new ArgumentNullException(nameof(valueSerializer)); + } + var valueType = valueSerializer.ValueType; var nullableSerializerType = typeof(NullableSerializer<>).MakeGenericType(valueType); return (IBsonSerializer)Activator.CreateInstance(nullableSerializerType, valueSerializer); diff --git a/tests/MongoDB.Bson.Tests/Exceptions/BsonExceptionTests.cs b/tests/MongoDB.Bson.Tests/Exceptions/BsonExceptionTests.cs new file mode 100644 index 00000000000..14287e70916 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Exceptions/BsonExceptionTests.cs @@ -0,0 +1,53 @@ +/* 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 FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.Exceptions +{ + public class BsonExceptionTests + { + [Fact] + public void constructor_with_format_and_args_should_format_message_correctly() + { + // Act + var exception = new BsonException("Error code: {0}, message: {1}", 123, "Test error"); + + // Assert + exception.Message.Should().Be("Error code: 123, message: Test error"); + } + + [Fact] + public void constructor_with_format_and_args_should_handle_empty_args() + { + // Act + var exception = new BsonException("Simple message"); + + // Assert + exception.Message.Should().Be("Simple message"); + } + + [Fact] + public void constructor_with_format_and_args_should_handle_null_args() + { + // Act + var exception = new BsonException("Message with {0}", (object)null); + + // Assert + exception.Message.Should().Be("Message with "); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Exceptions/BsonInternalExceptionTests.cs b/tests/MongoDB.Bson.Tests/Exceptions/BsonInternalExceptionTests.cs new file mode 100644 index 00000000000..fce871f8b4b --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Exceptions/BsonInternalExceptionTests.cs @@ -0,0 +1,74 @@ +/* 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; +using FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.Exceptions +{ + public class BsonInternalExceptionTests + { + [Fact] + public void constructor_should_initialize_empty_instance() + { + // Act + var exception = new BsonInternalException(); + + // Assert + exception.Message.Should().Be("Exception of type 'MongoDB.Bson.BsonInternalException' was thrown."); + exception.InnerException.Should().BeNull(); + } + + [Fact] + public void constructor_should_initialize_instance_with_message() + { + // Arrange + var message = "Test internal exception message"; + + // Act + var exception = new BsonInternalException(message); + + // Assert + exception.Message.Should().Be(message); + exception.InnerException.Should().BeNull(); + } + + [Fact] + public void constructor_should_initialize_instance_with_message_and_inner_exception() + { + // Arrange + var message = "Test internal exception message"; + var innerException = new Exception("Inner exception message"); + + // Act + var exception = new BsonInternalException(message, innerException); + + // Assert + exception.Message.Should().Be(message); + exception.InnerException.Should().BeSameAs(innerException); + } + + [Fact] + public void should_inherit_from_bson_exception() + { + // Act + var exception = new BsonInternalException(); + + // Assert + exception.Should().BeAssignableTo(); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Exceptions/BsonSerializationExceptionTests.cs b/tests/MongoDB.Bson.Tests/Exceptions/BsonSerializationExceptionTests.cs new file mode 100644 index 00000000000..4c0fac93c66 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Exceptions/BsonSerializationExceptionTests.cs @@ -0,0 +1,39 @@ +/* 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; +using FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.Exceptions +{ + public class BsonSerializationExceptionTests + { + [Fact] + public void Constructor_with_message_and_inner_exception_should_initialize_properties() + { + // Arrange + var message = "Test error message"; + var innerException = new ArgumentException("Inner exception message"); + + // Act + var exception = new BsonSerializationException(message, innerException); + + // Assert + exception.Message.Should().Be(message); + exception.InnerException.Should().BeSameAs(innerException); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/IO/DateTimeJsonTokenTests.cs b/tests/MongoDB.Bson.Tests/IO/DateTimeJsonTokenTests.cs new file mode 100644 index 00000000000..66f24afb62d --- /dev/null +++ b/tests/MongoDB.Bson.Tests/IO/DateTimeJsonTokenTests.cs @@ -0,0 +1,69 @@ +/* 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; +using FluentAssertions; +using MongoDB.Bson.IO; +using Xunit; + +namespace MongoDB.Bson.Tests.IO +{ + public class DateTimeJsonTokenTests + { + [Fact] + public void Constructor_should_initialize_token_with_provided_values() + { + // Arrange + var lexeme = "ISODate(\"2023-01-01T00:00:00Z\")"; + var value = new BsonDateTime(new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc)); + + // Act + var token = new DateTimeJsonToken(lexeme, value); + + // Assert + token.Lexeme.Should().Be(lexeme); + token.Type.Should().Be(JsonTokenType.DateTime); + } + + [Fact] + public void Constructor_should_set_token_type_to_DateTime() + { + // Arrange + var lexeme = "ISODate(\"2023-01-01T00:00:00Z\")"; + var value = new BsonDateTime(new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc)); + + // Act + var token = new DateTimeJsonToken(lexeme, value); + + // Assert + token.Type.Should().Be(JsonTokenType.DateTime); + } + + [Fact] + public void DateTimeValue_should_return_provided_value() + { + // Arrange + var lexeme = "ISODate(\"2023-01-01T00:00:00Z\")"; + var value = new BsonDateTime(new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc)); + var token = new DateTimeJsonToken(lexeme, value); + + // Act + var result = token.DateTimeValue; + + // Assert + result.Should().Be(value); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/IO/ObjectIdJsonTokenTests.cs b/tests/MongoDB.Bson.Tests/IO/ObjectIdJsonTokenTests.cs new file mode 100644 index 00000000000..093457728cd --- /dev/null +++ b/tests/MongoDB.Bson.Tests/IO/ObjectIdJsonTokenTests.cs @@ -0,0 +1,68 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.IO; +using Xunit; + +namespace MongoDB.Bson.Tests.IO +{ + public class ObjectIdJsonTokenTests + { + [Fact] + public void Constructor_should_initialize_token_with_provided_values() + { + // Arrange + var lexeme = "ObjectId(\"507f1f77bcf86cd799439011\")"; + var value = new ObjectId("507f1f77bcf86cd799439011"); + + // Act + var token = new ObjectIdJsonToken(lexeme, value); + + // Assert + token.Lexeme.Should().Be(lexeme); + token.Type.Should().Be(JsonTokenType.ObjectId); + } + + [Fact] + public void Constructor_should_set_token_type_to_ObjectId() + { + // Arrange + var lexeme = "ObjectId(\"507f1f77bcf86cd799439011\")"; + var value = new ObjectId("507f1f77bcf86cd799439011"); + + // Act + var token = new ObjectIdJsonToken(lexeme, value); + + // Assert + token.Type.Should().Be(JsonTokenType.ObjectId); + } + + [Fact] + public void ObjectIdValue_should_return_provided_value() + { + // Arrange + var lexeme = "ObjectId(\"507f1f77bcf86cd799439011\")"; + var value = new ObjectId("507f1f77bcf86cd799439011"); + var token = new ObjectIdJsonToken(lexeme, value); + + // Act + var result = token.ObjectIdValue; + + // Assert + result.Should().Be(value); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptTests.cs b/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptTests.cs new file mode 100644 index 00000000000..b79c3cade87 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptTests.cs @@ -0,0 +1,387 @@ +/* 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; +using FluentAssertions; +using MongoDB.Shared; +using Xunit; + +namespace MongoDB.Bson.Tests.ObjectModel +{ + public class BsonJavaScriptTests + { + [Fact] + public void BsonType_should_return_JavaScript() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + + // Act + var result = subject.BsonType; + + // Assert + result.Should().Be(BsonType.JavaScript); + } + + [Fact] + public void Code_should_return_code_provided_in_constructor() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + + // Act + var result = subject.Code; + + // Assert + result.Should().Be(code); + } + + [Fact] + public void CompareTo_BsonJavaScript_should_return_0_when_codes_are_equal() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + var other = new BsonJavaScript(code); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(0); + } + + [Fact] + public void CompareTo_BsonJavaScript_should_return_1_when_other_is_null() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + + // Act + var result = subject.CompareTo((BsonJavaScript)null); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonJavaScript_should_return_negative_when_this_code_is_less_than_other_code() + { + // Arrange + var subject = new BsonJavaScript("a"); + var other = new BsonJavaScript("b"); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().BeLessThan(0); + } + + [Fact] + public void CompareTo_BsonJavaScript_should_return_positive_when_this_code_is_greater_than_other_code() + { + // Arrange + var subject = new BsonJavaScript("b"); + var other = new BsonJavaScript("a"); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().BeGreaterThan(0); + } + [Fact] + public void CompareTo_BsonValue_should_compare_code_when_other_is_BsonJavaScript() + { + // Arrange + var subject = new BsonJavaScript("a"); + BsonValue other = new BsonJavaScript("b"); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().BeLessThan(0); + } + + [Fact] + public void CompareTo_BsonValue_should_return_1_when_other_is_null() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + + // Act + var result = subject.CompareTo((BsonValue)null); + + // Assert + result.Should().Be(1); + } + [Fact] + public void CompareTo_BsonValue_should_use_CompareTypeTo_when_other_is_not_BsonJavaScript() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + var other = new BsonInt32(1); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().NotBe(0); + // The actual comparison result depends on BsonType enum values + } + + [Fact] + public void Constructor_should_initialize_Code_property() + { + // Arrange + var code = "function() { return 1; }"; + + // Act + var subject = new BsonJavaScript(code); + + // Assert + subject.Code.Should().Be(code); + } + + [Fact] + public void Constructor_should_throw_when_code_is_null() + { + // Arrange & Act + Action act = () => new BsonJavaScript(null); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("code"); + } + + [Fact] + public void Create_should_map_value_to_BsonJavaScript() + { + // Arrange + var code = "function() { return 1; }"; + + // Act + var result = BsonJavaScript.Create(code); + + // Assert + result.Should().NotBeNull(); + result.Code.Should().Be(code); + } + + [Fact] + public void Create_should_throw_when_value_is_null() + { + // Act + Action act = () => BsonJavaScript.Create(null); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("value"); + } + + [Fact] + public void Equality_operator_should_return_false_when_codes_are_not_equal() + { + // Arrange + var lhs = new BsonJavaScript("function() { return 1; }"); + var rhs = new BsonJavaScript("function() { return 2; }"); + + // Act + var result = lhs == rhs; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equality_operator_should_return_true_when_codes_are_equal() + { + // Arrange + var code = "function() { return 1; }"; + var lhs = new BsonJavaScript(code); + var rhs = new BsonJavaScript(code); + + // Act + var result = lhs == rhs; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_BsonJavaScript_should_return_false_when_codes_are_not_equal() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + var other = new BsonJavaScript("function() { return 2; }"); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonJavaScript_should_return_false_when_other_is_different_type() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + var other = new BsonJavaScriptWithScope("function() { return 1; }", new BsonDocument()); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonJavaScript_should_return_false_when_other_is_null() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + + // Act + var result = subject.Equals((BsonJavaScript)null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonJavaScript_should_return_true_when_codes_are_equal() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + var other = new BsonJavaScript(code); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void Equals_object_should_return_false_when_other_is_not_BsonJavaScript() + { + // Arrange + var subject = new BsonJavaScript("function() { return 1; }"); + object other = "function() { return 1; }"; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_true_when_other_is_BsonJavaScript_with_equal_code() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + object other = new BsonJavaScript(code); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void GetHashCode_should_return_combination_of_BsonType_and_code_hash_codes() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + + // Calculate expected hash code using same algorithm as in the class + int expectedHash = 17; + expectedHash = 37 * expectedHash + Hasher.GetHashCode(BsonType.JavaScript); + expectedHash = 37 * expectedHash + code.GetHashCode(); + + // Act + var result = subject.GetHashCode(); + + // Assert + result.Should().Be(expectedHash); + } + + [Fact] + public void Implicit_conversion_from_string_should_create_BsonJavaScript_instance() + { + // Arrange + var code = "function() { return 1; }"; + + // Act + BsonJavaScript result = code; + + // Assert + result.Should().NotBeNull(); + result.Code.Should().Be(code); + } + + [Fact] + public void Inequality_operator_should_return_false_when_codes_are_equal() + { + // Arrange + var code = "function() { return 1; }"; + var lhs = new BsonJavaScript(code); + var rhs = new BsonJavaScript(code); + + // Act + var result = lhs != rhs; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Inequality_operator_should_return_true_when_codes_are_not_equal() + { + // Arrange + var lhs = new BsonJavaScript("function() { return 1; }"); + var rhs = new BsonJavaScript("function() { return 2; }"); + + // Act + var result = lhs != rhs; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void ToString_should_return_formatted_string_representation() + { + // Arrange + var code = "function() { return 1; }"; + var subject = new BsonJavaScript(code); + var expected = $"new BsonJavaScript(\"{code}\")"; + + // Act + var result = subject.ToString(); + + // Assert + result.Should().Be(expected); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptWithScopeTests.cs b/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptWithScopeTests.cs new file mode 100644 index 00000000000..91ead7e9ec7 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/ObjectModel/BsonJavaScriptWithScopeTests.cs @@ -0,0 +1,452 @@ +/* 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; +using FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.ObjectModel +{ + public class BsonJavaScriptWithScopeTests + { + [Fact] + public void BsonType_should_return_JavaScriptWithScope() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + + // Act + var result = subject.BsonType; + + // Assert + result.Should().Be(BsonType.JavaScriptWithScope); + } + + [Fact] + public void Clone_should_create_shallow_copy() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + + // Act + var result = subject.Clone(); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType(); + var clone = (BsonJavaScriptWithScope)result; + clone.Code.Should().Be(subject.Code); + clone.Scope.Should().NotBeSameAs(subject.Scope); + clone.Scope["x"].Should().Be(1); + clone.Scope["y"].Should().Be(2); + } + + [Fact] + public void CompareTo_BsonJavaScriptWithScope_should_compare_code_first_then_scope() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 2 }, { "y", 3 } }; + var subject1 = new BsonJavaScriptWithScope("a", scope1); + var subject2 = new BsonJavaScriptWithScope("b", scope1); + var subject3 = new BsonJavaScriptWithScope("a", scope2); + + // Act + var result1 = subject1.CompareTo(subject2); // code comparison: a < b + var result2 = subject2.CompareTo(subject1); // code comparison: b > a + var result3 = subject1.CompareTo(subject3); // same code, different scope + var result4 = subject1.CompareTo(subject1); // same instance + + // Assert + result1.Should().BeLessThan(0); + result2.Should().BeGreaterThan(0); + result3.Should().BeLessThan(0); // scope1 < scope2 + result4.Should().Be(0); + } + + [Fact] + public void CompareTo_BsonJavaScriptWithScope_should_return_1_when_other_is_null() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + BsonJavaScriptWithScope other = null; + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_return_1_when_other_is_null() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + BsonValue other = null; + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_use_CompareTo_when_other_is_BsonJavaScriptWithScope() + { + // Arrange + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope("a", scope); + BsonValue other = new BsonJavaScriptWithScope("b", scope); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().BeLessThan(0); + } + + [Fact] + public void CompareTo_BsonValue_should_use_CompareTypeTo_when_other_is_not_BsonJavaScriptWithScope() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + var other = new BsonInt32(1); + + // Act + var result = subject.CompareTo(other); + + // Assert + // BsonJavaScriptWithScope has a higher BsonType enum value than BsonInt32 + result.Should().BeGreaterThan(0); + } + + [Fact] + public void Constructor_should_initialize_instance() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + + // Act + var result = new BsonJavaScriptWithScope(code, scope); + + // Assert + result.Code.Should().Be(code); + result.Scope.Should().BeSameAs(scope); + } + + [Fact] + public void Constructor_should_throw_when_scope_is_null() + { + // Arrange + var code = "function() { return x + y; }"; + BsonDocument scope = null; + + // Act + Action act = () => new BsonJavaScriptWithScope(code, scope); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("scope"); + } + + [Fact] + public void DeepClone_should_create_deep_copy() + { + // Arrange + var code = "function() { return x + y; }"; + var nestedDoc = new BsonDocument { { "a", 3 } }; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 }, { "z", nestedDoc } }; + var subject = new BsonJavaScriptWithScope(code, scope); + + // Act + var result = subject.DeepClone(); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType(); + var clone = (BsonJavaScriptWithScope)result; + clone.Code.Should().Be(subject.Code); + clone.Scope.Should().NotBeSameAs(subject.Scope); + clone.Scope["x"].Should().Be(1); + clone.Scope["y"].Should().Be(2); + clone.Scope["z"].Should().NotBeSameAs(nestedDoc); + clone.Scope["z"].AsBsonDocument["a"].Should().Be(3); + + // Modify the nested document to ensure deep clone + nestedDoc["a"] = 4; + clone.Scope["z"].AsBsonDocument["a"].Should().Be(3); // Should still be 3 + } + + [Fact] + public void Equality_operator_should_handle_null() + { + // Arrange + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope("code", scope); + BsonJavaScriptWithScope nullValue = null; + + // Act + var resultLeftNull = nullValue == subject; + var resultRightNull = subject == nullValue; + + // Assert + resultLeftNull.Should().BeFalse(); + resultRightNull.Should().BeFalse(); + } + + [Fact] + public void Equality_operator_should_return_false_when_not_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 3 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + var subject3 = new BsonJavaScriptWithScope("different", scope1); + + // Act + var resultDifferentScope = subject1 == subject2; + var resultDifferentCode = subject1 == subject3; + + // Assert + resultDifferentScope.Should().BeFalse(); + resultDifferentCode.Should().BeFalse(); + } + + [Fact] + public void Equality_operator_should_return_true_when_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + + // Act + var result = subject1 == subject2; + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void Equals_BsonJavaScriptWithScope_should_return_false_when_not_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 3 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + var subject3 = new BsonJavaScriptWithScope("different", scope1); + + // Act + var resultDifferentScope = subject1.Equals(subject2); + var resultDifferentCode = subject1.Equals(subject3); + + // Assert + resultDifferentScope.Should().BeFalse(); + resultDifferentCode.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonJavaScriptWithScope_should_return_false_when_other_is_null() + { + // Arrange + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope("code", scope); + BsonJavaScriptWithScope other = null; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonJavaScriptWithScope_should_return_true_when_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void Equals_object_should_return_false_when_other_is_different_type() + { + // Arrange + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope("code", scope); + object other = "not a BsonJavaScriptWithScope"; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_false_when_other_is_null() + { + // Arrange + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope("code", scope); + object other = null; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_true_when_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + object subject2 = new BsonJavaScriptWithScope("code", scope2); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void GetHashCode_should_return_different_values_for_unequal_instances() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 3 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + var subject3 = new BsonJavaScriptWithScope("different", scope1); + + // Act + var hashCode1 = subject1.GetHashCode(); + var hashCode2 = subject2.GetHashCode(); + var hashCode3 = subject3.GetHashCode(); + + // Assert + hashCode1.Should().NotBe(hashCode2); + hashCode1.Should().NotBe(hashCode3); + } + + [Fact] + public void GetHashCode_should_return_same_value_for_equal_instances() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + + // Act + var hashCode1 = subject1.GetHashCode(); + var hashCode2 = subject2.GetHashCode(); + + // Assert + hashCode1.Should().Be(hashCode2); + } + [Fact] + public void Inequality_operator_should_return_false_when_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + + // Act + var result = subject1 != subject2; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Inequality_operator_should_return_true_when_not_equal() + { + // Arrange + var scope1 = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var scope2 = new BsonDocument { { "x", 1 }, { "y", 3 } }; + var subject1 = new BsonJavaScriptWithScope("code", scope1); + var subject2 = new BsonJavaScriptWithScope("code", scope2); + var subject3 = new BsonJavaScriptWithScope("different", scope1); + + // Act + var resultDifferentScope = subject1 != subject2; + var resultDifferentCode = subject1 != subject3; + + // Assert + resultDifferentScope.Should().BeTrue(); + resultDifferentCode.Should().BeTrue(); + } + + [Fact] + public void Scope_property_should_return_the_scope() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + + // Act + var result = subject.Scope; + + // Assert + result.Should().BeSameAs(scope); + } + + [Fact] + public void ToString_should_return_formatted_string() + { + // Arrange + var code = "function() { return x + y; }"; + var scope = new BsonDocument { { "x", 1 }, { "y", 2 } }; + var subject = new BsonJavaScriptWithScope(code, scope); + var expectedString = "new BsonJavaScript(\"function() { return x + y; }\", { \"x\" : 1, \"y\" : 2 })"; + + // Act + var result = subject.ToString(); + + // Assert + result.Should().Be(expectedString); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/ObjectModel/BsonSymbolTests.cs b/tests/MongoDB.Bson.Tests/ObjectModel/BsonSymbolTests.cs new file mode 100644 index 00000000000..0908958e698 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/ObjectModel/BsonSymbolTests.cs @@ -0,0 +1,285 @@ +/* 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; +using FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.ObjectModel +{ + public class BsonSymbolTests + { + [Fact] + public void BsonType_should_return_Symbol() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + + // Act + var bsonType = symbol.BsonType; + + // Assert + bsonType.Should().Be(BsonType.Symbol); + } + + [Fact] + public void CompareTo_BsonSymbol_should_compare_names() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("abc"); + var symbol2 = BsonSymbolTable.Lookup("def"); + var symbol3 = BsonSymbolTable.Lookup("abc"); + + // Act + var result1 = symbol1.CompareTo(symbol2); + var result2 = symbol2.CompareTo(symbol1); + var result3 = symbol1.CompareTo(symbol3); + + // Assert + result1.Should().BeLessThan(0); + result2.Should().BeGreaterThan(0); + result3.Should().Be(0); + } + + [Fact] + public void CompareTo_BsonSymbol_should_return_1_when_other_is_null() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol.CompareTo((BsonSymbol)null); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_compare_names_when_other_is_BsonString() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("abc"); + var bsonString = new BsonString("def"); + + // Act + var result = symbol.CompareTo(bsonString); + + // Assert + result.Should().BeLessThan(0); + } + + [Fact] + public void CompareTo_BsonValue_should_compare_names_when_other_is_BsonSymbol() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("abc"); + var symbol2 = BsonSymbolTable.Lookup("def"); + BsonValue value2 = symbol2; + + // Act + var result = symbol1.CompareTo(value2); + + // Assert + result.Should().BeLessThan(0); + } + [Fact] + public void CompareTo_BsonValue_should_return_1_when_other_is_null() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol.CompareTo((BsonValue)null); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_use_CompareTypeTo_when_other_is_different_BsonType() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("abc"); + var int32 = new BsonInt32(123); + + // Act + var result = symbol.CompareTo(int32); + + // Assert + // Symbol's enum value is greater than Int32's enum value + result.Should().BeGreaterThan(0); + } + [Fact] + public void Create_should_map_value_to_BsonSymbol() + { + // Arrange + var value = "test"; + + // Act + var symbol = BsonSymbol.Create(value); + + // Assert + symbol.Should().NotBeNull(); + symbol.Name.Should().Be(value); + } + + [Fact] + public void Create_should_throw_when_value_is_null() + { + // Act + Action act = () => BsonSymbol.Create(null); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("value"); + } + + [Fact] + public void Equality_operator_should_return_true_when_symbols_are_same_instance() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("test"); + var symbol2 = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol1 == symbol2; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_BsonSymbol_should_return_false_when_other_is_null() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol.Equals((BsonSymbol)null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonSymbol_should_return_true_when_symbols_are_same_instance() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("test"); + var symbol2 = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol1.Equals(symbol2); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void Equals_object_should_return_false_when_other_is_different_type() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + object other = "test"; + + // Act + var result = symbol.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_false_when_other_is_null() + { + // Arrange + var symbol = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol.Equals(null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_true_when_other_is_same_symbol() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("test"); + object symbol2 = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol1.Equals(symbol2); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void GetHashCode_should_return_same_value_for_same_symbol() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("test"); + var symbol2 = BsonSymbolTable.Lookup("test"); + + // Act + var hashCode1 = symbol1.GetHashCode(); + var hashCode2 = symbol2.GetHashCode(); + + // Assert + hashCode1.Should().Be(hashCode2); + } + + [Fact] + public void Implicit_operator_string_to_BsonSymbol_should_lookup_symbol() + { + // Arrange + string symbolName = "test"; + + // Act + BsonSymbol symbol = symbolName; + + // Assert + symbol.Should().NotBeNull(); + symbol.Name.Should().Be(symbolName); + } + + [Fact] + public void Inequality_operator_should_return_false_when_symbols_are_same_instance() + { + // Arrange + var symbol1 = BsonSymbolTable.Lookup("test"); + var symbol2 = BsonSymbolTable.Lookup("test"); + + // Act + var result = symbol1 != symbol2; + + // Assert + result.Should().BeFalse(); + } + [Fact] + public void ToString_should_return_name() + { + // Arrange + var symbolName = "test"; + var symbol = BsonSymbolTable.Lookup(symbolName); + + // Act + var result = symbol.ToString(); + + // Assert + result.Should().Be(symbolName); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/ObjectModel/BsonTypeMapperOptionsTests.cs b/tests/MongoDB.Bson.Tests/ObjectModel/BsonTypeMapperOptionsTests.cs new file mode 100644 index 00000000000..48b8670d362 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/ObjectModel/BsonTypeMapperOptionsTests.cs @@ -0,0 +1,289 @@ +/* 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; +using System.Collections.Generic; +using FluentAssertions; +using Xunit; + +namespace MongoDB.Bson.Tests.ObjectModel +{ + public class BsonTypeMapperOptionsTests + { + [Fact] + public void Clone_should_create_independent_copy_with_same_values() + { + // Arrange + var original = new BsonTypeMapperOptions + { + DuplicateNameHandling = DuplicateNameHandling.ThrowException, + MapBsonArrayTo = typeof(object[]), + MapBsonDocumentTo = typeof(Dictionary), + MapOldBinaryToByteArray = true + }; + + // Act + var clone = original.Clone(); + + // Assert + clone.Should().NotBeSameAs(original); + clone.DuplicateNameHandling.Should().Be(original.DuplicateNameHandling); + clone.MapBsonArrayTo.Should().Be(original.MapBsonArrayTo); + clone.MapBsonDocumentTo.Should().Be(original.MapBsonDocumentTo); + clone.MapOldBinaryToByteArray.Should().Be(original.MapOldBinaryToByteArray); + clone.IsFrozen.Should().BeFalse(); + } + + [Fact] + public void Constructor_should_initialize_default_values() + { + // Act + var options = new BsonTypeMapperOptions(); + + // Assert + options.DuplicateNameHandling.Should().Be(DuplicateNameHandling.Overwrite); + options.MapBsonArrayTo.Should().Be(typeof(List)); + options.MapBsonDocumentTo.Should().Be(typeof(Dictionary)); + options.MapOldBinaryToByteArray.Should().BeFalse(); + options.IsFrozen.Should().BeFalse(); + } + + [Fact] + public void Defaults_get_should_return_default_options_instance() + { + // Act + var defaults = BsonTypeMapperOptions.Defaults; + + // Assert + defaults.Should().NotBeNull(); + defaults.IsFrozen.Should().BeTrue(); + } + + [Fact] + public void Defaults_set_should_freeze_clone_when_value_is_not_frozen() + { + // Arrange + var originalDefaults = BsonTypeMapperOptions.Defaults; + var newOptions = new BsonTypeMapperOptions + { + DuplicateNameHandling = DuplicateNameHandling.ThrowException + }; + + try + { + // Act + BsonTypeMapperOptions.Defaults = newOptions; + + // Assert + BsonTypeMapperOptions.Defaults.Should().NotBeSameAs(newOptions); + BsonTypeMapperOptions.Defaults.DuplicateNameHandling.Should().Be(DuplicateNameHandling.ThrowException); + BsonTypeMapperOptions.Defaults.IsFrozen.Should().BeTrue(); + } + finally + { + // Restore original defaults + BsonTypeMapperOptions.Defaults = originalDefaults; + } + } + + [Fact] + public void Defaults_set_should_use_frozen_instance_when_value_is_frozen() + { + // Arrange + var originalDefaults = BsonTypeMapperOptions.Defaults; + var newFrozenOptions = new BsonTypeMapperOptions + { + DuplicateNameHandling = DuplicateNameHandling.ThrowException + }.Freeze(); + + try + { + // Act + BsonTypeMapperOptions.Defaults = newFrozenOptions; + + // Assert + BsonTypeMapperOptions.Defaults.Should().BeSameAs(newFrozenOptions); + BsonTypeMapperOptions.Defaults.DuplicateNameHandling.Should().Be(DuplicateNameHandling.ThrowException); + } + finally + { + // Restore original defaults + BsonTypeMapperOptions.Defaults = originalDefaults; + } + } + + [Fact] + public void DuplicateNameHandling_get_should_return_set_value() + { + // Arrange + var options = new BsonTypeMapperOptions + { + DuplicateNameHandling = DuplicateNameHandling.ThrowException + }; + + // Act + var result = options.DuplicateNameHandling; + + // Assert + result.Should().Be(DuplicateNameHandling.ThrowException); + } + + [Fact] + public void DuplicateNameHandling_set_should_throw_when_instance_is_frozen() + { + // Arrange + var options = new BsonTypeMapperOptions().Freeze(); + + // Act + Action act = () => options.DuplicateNameHandling = DuplicateNameHandling.ThrowException; + + // Assert + act.ShouldThrow() + .WithMessage("BsonTypeMapperOptions is frozen."); + } + + [Fact] + public void Freeze_should_be_idempotent() + { + // Arrange + var options = new BsonTypeMapperOptions(); + options.Freeze(); + + // Act + var result = options.Freeze(); + + // Assert + result.Should().BeSameAs(options); + result.IsFrozen.Should().BeTrue(); + } + + [Fact] + public void Freeze_should_set_IsFrozen_to_true() + { + // Arrange + var options = new BsonTypeMapperOptions(); + + // Act + var result = options.Freeze(); + + // Assert + result.Should().BeSameAs(options); + result.IsFrozen.Should().BeTrue(); + } + + [Fact] + public void IsFrozen_get_should_return_false_by_default() + { + // Arrange + var options = new BsonTypeMapperOptions(); + + // Act + var result = options.IsFrozen; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void MapBsonArrayTo_get_should_return_set_value() + { + // Arrange + var options = new BsonTypeMapperOptions + { + MapBsonArrayTo = typeof(object[]) + }; + + // Act + var result = options.MapBsonArrayTo; + + // Assert + result.Should().Be(typeof(object[])); + } + + [Fact] + public void MapBsonArrayTo_set_should_throw_when_instance_is_frozen() + { + // Arrange + var options = new BsonTypeMapperOptions().Freeze(); + + // Act + Action act = () => options.MapBsonArrayTo = typeof(object[]); + + // Assert + act.ShouldThrow() + .WithMessage("BsonTypeMapperOptions is frozen."); + } + + [Fact] + public void MapBsonDocumentTo_get_should_return_set_value() + { + // Arrange + var options = new BsonTypeMapperOptions + { + MapBsonDocumentTo = typeof(Dictionary) + }; + + // Act + var result = options.MapBsonDocumentTo; + + // Assert + result.Should().Be(typeof(Dictionary)); + } + + [Fact] + public void MapBsonDocumentTo_set_should_throw_when_instance_is_frozen() + { + // Arrange + var options = new BsonTypeMapperOptions().Freeze(); + + // Act + Action act = () => options.MapBsonDocumentTo = typeof(Dictionary); + + // Assert + act.ShouldThrow() + .WithMessage("BsonTypeMapperOptions is frozen."); + } + + [Fact] + public void MapOldBinaryToByteArray_get_should_return_set_value() + { + // Arrange + var options = new BsonTypeMapperOptions + { + MapOldBinaryToByteArray = true + }; + + // Act + var result = options.MapOldBinaryToByteArray; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void MapOldBinaryToByteArray_set_should_throw_when_instance_is_frozen() + { + // Arrange + var options = new BsonTypeMapperOptions().Freeze(); + + // Act + Action act = () => options.MapOldBinaryToByteArray = true; + + // Assert + act.ShouldThrow() + .WithMessage("BsonTypeMapperOptions is frozen."); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/ObjectModel/BsonUndefinedTests.cs b/tests/MongoDB.Bson.Tests/ObjectModel/BsonUndefinedTests.cs new file mode 100644 index 00000000000..fb0849a37c9 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/ObjectModel/BsonUndefinedTests.cs @@ -0,0 +1,308 @@ +/* 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 FluentAssertions; +using MongoDB.Shared; +using Xunit; + +namespace MongoDB.Bson.Tests.ObjectModel +{ + public class BsonUndefinedTests + { + [Fact] + public void BsonType_should_return_Undefined() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.BsonType; + + // Assert + result.Should().Be(BsonType.Undefined); + } + + [Fact] + public void CompareTo_BsonUndefined_should_return_0_when_comparing_to_another_BsonUndefined() + { + // Arrange + var subject = BsonUndefined.Value; + var other = BsonUndefined.Value; + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(0); + } + + [Fact] + public void CompareTo_BsonUndefined_should_return_1_when_other_is_null() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.CompareTo((BsonUndefined)null); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_return_0_when_other_is_BsonUndefined() + { + // Arrange + var subject = BsonUndefined.Value; + BsonValue other = BsonUndefined.Value; + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(0); + } + + [Fact] + public void CompareTo_BsonValue_should_return_1_when_other_is_BsonMinKey() + { + // Arrange + var subject = BsonUndefined.Value; + BsonValue other = BsonMinKey.Value; + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_return_1_when_other_is_null() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.CompareTo((BsonValue)null); + + // Assert + result.Should().Be(1); + } + + [Fact] + public void CompareTo_BsonValue_should_return_negative_1_when_other_is_neither_BsonUndefined_nor_BsonMinKey() + { + // Arrange + var subject = BsonUndefined.Value; + BsonValue other = new BsonInt32(1); + + // Act + var result = subject.CompareTo(other); + + // Assert + result.Should().Be(-1); + } + + [Fact] + public void Equality_operator_should_return_false_when_one_operand_is_null() + { + // Arrange + var lhs = BsonUndefined.Value; + BsonUndefined rhs = null; + + // Act + var result = lhs == rhs; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equality_operator_should_return_true_when_both_operands_are_BsonUndefined() + { + // Arrange + var lhs = BsonUndefined.Value; + var rhs = BsonUndefined.Value; + + // Act + var result = lhs == rhs; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_BsonUndefined_should_return_false_when_other_is_different_type() + { + // Arrange + var subject = BsonUndefined.Value; + var other = new object(); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonUndefined_should_return_false_when_other_is_null() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.Equals((BsonUndefined)null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_BsonUndefined_should_return_true_when_other_is_BsonUndefined() + { + // Arrange + var subject = BsonUndefined.Value; + var other = BsonUndefined.Value; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_object_should_return_false_when_other_is_different_type() + { + // Arrange + var subject = BsonUndefined.Value; + object other = new BsonInt32(1); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_false_when_other_is_null() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.Equals((object)null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_object_should_return_true_when_other_is_BsonUndefined() + { + // Arrange + var subject = BsonUndefined.Value; + object other = BsonUndefined.Value; + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void GetHashCode_should_return_hash_code_of_BsonType() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.GetHashCode(); + + // Assert + result.Should().Be(Hasher.GetHashCode(BsonType.Undefined)); + } + + [Fact] + public void Inequality_operator_should_return_false_when_both_operands_are_BsonUndefined() + { + // Arrange + var lhs = BsonUndefined.Value; + var rhs = BsonUndefined.Value; + + // Act + var result = lhs != rhs; + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Inequality_operator_should_return_true_when_one_operand_is_null() + { + // Arrange + var lhs = BsonUndefined.Value; + BsonUndefined rhs = null; + + // Act + var result = lhs != rhs; + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void ToBoolean_should_return_false() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.ToBoolean(); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void ToString_should_return_BsonUndefined() + { + // Arrange + var subject = BsonUndefined.Value; + + // Act + var result = subject.ToString(); + + // Assert + result.Should().Be("BsonUndefined"); + } + + [Fact] + public void Value_should_return_singleton_instance() + { + // Act + var instance1 = BsonUndefined.Value; + var instance2 = BsonUndefined.Value; + + // Assert + instance1.Should().NotBeNull(); + instance1.Should().BeSameAs(instance2); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/BsonDeserializationArgsTests.cs b/tests/MongoDB.Bson.Tests/Serialization/BsonDeserializationArgsTests.cs new file mode 100644 index 00000000000..d81e390f602 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/BsonDeserializationArgsTests.cs @@ -0,0 +1,88 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization +{ + public class BsonDeserializationArgsTests + { + [Fact] + public void Empty_instance_should_have_null_NominalType() + { + // Arrange + var args = new BsonDeserializationArgs(); + + // Act + var nominalType = args.NominalType; + + // Assert + nominalType.Should().BeNull(); + } + + [Fact] + public void NominalType_property_should_allow_null_value() + { + // Arrange + var args = new BsonDeserializationArgs + { + NominalType = typeof(int) + }; + + // Act + args.NominalType = null; + var result = args.NominalType; + + // Assert + result.Should().BeNull(); + } + + [Fact] + public void NominalType_property_should_be_updatable() + { + // Arrange + var args = new BsonDeserializationArgs(); + var firstType = typeof(int); + var secondType = typeof(string); + + // Act + args.NominalType = firstType; + var firstResult = args.NominalType; + args.NominalType = secondType; + var secondResult = args.NominalType; + + // Assert + firstResult.Should().BeSameAs(firstType); + secondResult.Should().BeSameAs(secondType); + } + + [Fact] + public void NominalType_property_should_return_set_value() + { + // Arrange + var args = new BsonDeserializationArgs(); + var expectedType = typeof(string); + + // Act + args.NominalType = expectedType; + var result = args.NominalType; + + // Assert + result.Should().BeSameAs(expectedType); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/BsonDocumentBackedClassTests.cs b/tests/MongoDB.Bson.Tests/Serialization/BsonDocumentBackedClassTests.cs new file mode 100644 index 00000000000..4fd3d9f4d2f --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/BsonDocumentBackedClassTests.cs @@ -0,0 +1,248 @@ +/* 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; +using System.Collections.Generic; +using FluentAssertions; +using MongoDB.Bson.Serialization; +using Moq; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization +{ + public class BsonDocumentBackedClassTests + { + [Fact] + public void Constructor_should_initialize_with_provided_document_and_serializer() + { + // Arrange + var mockSerializer = new Mock(); + var document = new BsonDocument(); + + // Act + var testClass = new TestBsonDocumentBackedClass(document, mockSerializer.Object); + + // Assert + testClass.GetBackingDocument().Should().BeSameAs(document); + } + + [Fact] + public void Constructor_should_initialize_with_new_document_and_serializer() + { + // Arrange + var mockSerializer = new Mock(); + + // Act + var testClass = new TestBsonDocumentBackedClass(mockSerializer.Object); + + // Assert + testClass.GetBackingDocument().Should().NotBeNull(); + testClass.GetBackingDocument().ElementCount.Should().Be(0); + } + + [Fact] + public void Constructor_should_throw_when_backingDocument_is_null() + { + // Arrange + var mockSerializer = new Mock(); + + // Act + Action action = () => new TestBsonDocumentBackedClass(null, mockSerializer.Object); + + // Assert + action.ShouldThrow() + .And.ParamName.Should().Be("backingDocument"); + } + + [Fact] + public void Constructor_should_throw_when_serializer_is_null() + { + // Arrange + var document = new BsonDocument(); + + // Act + Action action = () => new TestBsonDocumentBackedClass(document, null); + + // Assert + action.ShouldThrow() + .And.ParamName.Should().Be("serializer"); + } + + [Fact] + public void BackingDocument_should_return_backing_document() + { + // Arrange + var mockSerializer = new Mock(); + var document = new BsonDocument(); + var testClass = new TestBsonDocumentBackedClass(document, mockSerializer.Object); + + // Act + var result = testClass.GetBackingDocument(); + + // Assert + result.Should().BeSameAs(document); + } + + [Fact] + public void GetValue_should_throw_when_member_does_not_exist() + { + // Arrange + var memberName = "nonExistingMember"; + var mockSerializer = new Mock(); + + mockSerializer + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Returns(false); + + var testClass = new TestBsonDocumentBackedClass(mockSerializer.Object); + + // Act + Action action = () => testClass.GetValue(memberName); + + // Assert + action.ShouldThrow() + .And.ParamName.Should().Be("memberName"); + } + + [Fact] + public void GetValue_should_throw_when_element_not_found() + { + // Arrange + var memberName = "testMember"; + var elementName = "testElement"; + + var document = new BsonDocument(); // Empty document + var mockSerializer = new Mock(); + var serializationInfo = new BsonSerializationInfo(elementName, mockSerializer.Object, typeof(BsonDocument)); + + mockSerializer + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Callback((string name, out BsonSerializationInfo info) => { info = serializationInfo; }) + .Returns(true); + + var testClass = new TestBsonDocumentBackedClass(document, mockSerializer.Object); + + // Act + Action action = () => testClass.GetValue(memberName); + + // Assert + action.ShouldThrow() + .WithMessage($"The backing document does not contain an element named '{elementName}'."); + } + + [Fact] + public void GetValue_with_default_should_return_default_when_element_not_found() + { + // Arrange + var memberName = "testMember"; + var elementName = "testElement"; + var defaultValue = 99; + + var document = new BsonDocument(); // Empty document + var mockSerializer = new Mock(); + var serializationInfo = new BsonSerializationInfo(elementName, mockSerializer.Object, typeof(BsonDocument)); + + mockSerializer + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Callback((string name, out BsonSerializationInfo info) => { info = serializationInfo; }) + .Returns(true); + + var testClass = new TestBsonDocumentBackedClass(document, mockSerializer.Object); + + // Act + var result = testClass.GetValue(memberName, defaultValue); + + // Assert + result.Should().Be(defaultValue); + } + + [Fact] + public void GetValue_with_default_should_throw_when_member_not_found() + { + // Arrange + var memberName = "nonExistingMember"; + var defaultValue = 99; + var mockSerializer = new Mock(); + + mockSerializer + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Returns(false); + + var testClass = new TestBsonDocumentBackedClass(mockSerializer.Object); + + // Act + Action action = () => testClass.GetValue(memberName, defaultValue); + + // Assert + action.ShouldThrow() + .And.ParamName.Should().Be("memberName"); + } + + [Fact] + public void SetValue_should_throw_when_member_not_found() + { + // Arrange + var memberName = "nonExistingMember"; + var value = 42; + var mockSerializer = new Mock(); + + mockSerializer + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Returns(false); + + var testClass = new TestBsonDocumentBackedClass(mockSerializer.Object); + + // Act + Action action = () => testClass.SetValue(memberName, value); + + // Assert + action.ShouldThrow() + .And.ParamName.Should().Be("memberName"); + } + + private class TestBsonDocumentBackedClass : BsonDocumentBackedClass + { + public TestBsonDocumentBackedClass(IBsonDocumentSerializer serializer) + : base(serializer) + { + } + + public TestBsonDocumentBackedClass(BsonDocument backingDocument, IBsonDocumentSerializer serializer) + : base(backingDocument, serializer) + { + } + + public BsonDocument GetBackingDocument() + { + return BackingDocument; + } + + public new T GetValue(string memberName) + { + return base.GetValue(memberName); + } + + public new T GetValue(string memberName, T defaultValue) + { + return base.GetValue(memberName, defaultValue); + } + + public new void SetValue(string memberName, object value) + { + base.SetValue(memberName, value); + } + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/BsonSerializationInfoTests.cs b/tests/MongoDB.Bson.Tests/Serialization/BsonSerializationInfoTests.cs index 7a11a06eeaa..9c5353b2e70 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/BsonSerializationInfoTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/BsonSerializationInfoTests.cs @@ -23,6 +23,113 @@ namespace MongoDB.Bson.Tests.Serialization { public class BsonSerializationInfoTests { + [Fact] + public void Constructor_with_element_name_should_initialize_properties() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + + // Act + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + + // Assert + info.ElementName.Should().Be(elementName); + info.Serializer.Should().BeSameAs(serializer); + info.NominalType.Should().Be(nominalType); + info.ElementPath.Should().BeNull(); + } + + [Fact] + public void CreateWithPath_should_handle_empty_path() + { + // Arrange + var elementPath = Array.Empty(); + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + + // Act + var info = BsonSerializationInfo.CreateWithPath(elementPath, serializer, nominalType); + + // Assert + info.ElementPath.Should().NotBeNull(); + info.ElementPath.Should().BeEmpty(); + } + + [Fact] + public void CreateWithPath_should_initialize_instance_with_element_path() + { + // Arrange + var elementPath = new[] { "parent", "child", "grandchild" }; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + + // Act + var info = BsonSerializationInfo.CreateWithPath(elementPath, serializer, nominalType); + + // Assert + info.Serializer.Should().BeSameAs(serializer); + info.NominalType.Should().Be(nominalType); + info.ElementPath.Should().NotBeNull(); + info.ElementPath.Count.Should().Be(3); + info.ElementPath.Should().Equal(elementPath); + + // Accessing ElementName should throw + Action act = () => { var name = info.ElementName; }; + act.ShouldThrow() + .WithMessage("When ElementPath is not null you must use it instead."); + } + + [Fact] + public void DeserializeValue_should_deserialize_bson_value() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + var value = new BsonInt32(42); + + // Act + var result = info.DeserializeValue(value); + + // Assert + result.Should().BeOfType(); + result.Should().Be(42); + } + + [Fact] + public void ElementName_should_throw_when_element_path_is_used() + { + // Arrange + var elementPath = new[] { "parent", "child" }; + var info = BsonSerializationInfo.CreateWithPath(elementPath, Int32Serializer.Instance, typeof(int)); + + // Act + Action act = () => { var name = info.ElementName; }; + + // Assert + act.ShouldThrow() + .WithMessage("When ElementPath is not null you must use it instead."); + } + + [Fact] + public void ElementPath_property_should_return_null_when_created_with_element_name() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + + // Act + var result = info.ElementPath; + + // Assert + result.Should().BeNull(); + } + [Fact] public void Equals_derived_should_return_false() { @@ -63,8 +170,27 @@ public void Equals_self_should_return_true() var result = x.Equals(x); result.Should().Be(true); + } + // TODO Should elementPath be compared as well? + //[Fact] + //public void Equals_with_element_path_should_compare_correctly() + //{ + // // Arrange + // var path1 = new[] { "parent", "child" }; + // var path2 = new[] { "parent", "child" }; + // var path3 = new[] { "different", "path" }; + + // var info1 = BsonSerializationInfo.CreateWithPath(path1, Int32Serializer.Instance, typeof(int)); + // var info2 = BsonSerializationInfo.CreateWithPath(path2, Int32Serializer.Instance, typeof(int)); + // var info3 = BsonSerializationInfo.CreateWithPath(path3, Int32Serializer.Instance, typeof(int)); + + // // Act & Assert + // info1.Equals(info2).Should().BeTrue(); + // info1.Equals(info3).Should().BeFalse(); + //} + [Fact] public void Equals_with_equal_fields_should_return_true() { @@ -106,6 +232,19 @@ public void Equals_with_not_equal_field_should_return_false(string notEqualField result.Should().Be(notEqualFieldName == null ? true : false); } + [Fact] + public void Equals_with_null_element_path_should_compare_correctly() + { + // Arrange + var info1 = new BsonSerializationInfo("name", Int32Serializer.Instance, typeof(int)); + var info2 = new BsonSerializationInfo("name", Int32Serializer.Instance, typeof(int)); + var info3 = new BsonSerializationInfo("different", Int32Serializer.Instance, typeof(int)); + + // Act & Assert + info1.Equals(info2).Should().BeTrue(); + info1.Equals(info3).Should().BeFalse(); + } + [Fact] public void GetHashCode_should_return_zero() { @@ -116,11 +255,118 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } - private class DerivedFromBsonSerializationInfo : BsonSerializationInfo + [Fact] + public void NominalType_property_should_return_configured_type() { - public DerivedFromBsonSerializationInfo(string elementName, IBsonSerializer serializer, Type nominalType) : base(elementName, serializer, nominalType) + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + + // Act + var result = info.NominalType; + + // Assert + result.Should().Be(nominalType); + } + + [Fact] + public void Serializer_property_should_return_configured_serializer() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + + // Act + var result = info.Serializer; + + // Assert + result.Should().BeSameAs(serializer); + } + + [Fact] + public void SerializeValue_should_serialize_value() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + var value = 42; + + // Act + var result = info.SerializeValue(value); + + // Assert + result.Should().BeOfType(); + result.AsInt32.Should().Be(42); + } + + [Fact] + public void SerializeValues_should_handle_empty_collection() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + var values = Array.Empty(); + + // Act + var result = info.SerializeValues(values); + + // Assert + result.Should().BeOfType(); + result.AsBsonArray.Count.Should().Be(0); + } + + [Fact] + public void SerializeValues_should_serialize_multiple_values() + { + // Arrange + var elementName = "testElement"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var info = new BsonSerializationInfo(elementName, serializer, nominalType); + var values = new[] { 1, 2, 3, 4, 5 }; + + // Act + var result = info.SerializeValues(values); + + // Assert + result.Should().BeOfType(); + result.AsBsonArray.Count.Should().Be(5); + for (var i = 0; i < 5; i++) { + result[i].AsInt32.Should().Be(i + 1); } } + + [Fact] + public void WithNewName_should_create_new_instance_with_different_name() + { + // Arrange + var originalName = "originalName"; + var newName = "newName"; + var serializer = Int32Serializer.Instance; + var nominalType = typeof(int); + var originalInfo = new BsonSerializationInfo(originalName, serializer, nominalType); + + // Act + var newInfo = originalInfo.WithNewName(newName); + + // Assert + newInfo.Should().NotBeSameAs(originalInfo); + newInfo.ElementName.Should().Be(newName); + newInfo.Serializer.Should().BeSameAs(serializer); + newInfo.NominalType.Should().Be(nominalType); + } + + private class DerivedFromBsonSerializationInfo(string elementName, IBsonSerializer serializer, Type nominalType) : BsonSerializationInfo(elementName, serializer, nominalType) + { + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetClassMapConventionTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetClassMapConventionTests.cs new file mode 100644 index 00000000000..2096b2656a7 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetClassMapConventionTests.cs @@ -0,0 +1,69 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Conventions; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.Conventions +{ + public class ResetClassMapConventionTests + { + [Fact] + public void Apply_should_call_reset_on_class_map() + { + // Arrange + var classMap = new BsonClassMap(); + classMap.SetIgnoreExtraElementsIsInherited(true); + + var subject = new ResetClassMapConvention(); + + // Act + subject.Apply(classMap); + + // Assert + classMap.IgnoreExtraElementsIsInherited.Should().Be(false); + } + + [Fact] + public void Apply_should_reset_class_map() + { + // Arrange + var classMap = new BsonClassMap(); + classMap.MapIdProperty(c => c.Id); + classMap.MapProperty(c => c.Name).SetElementName("custom_name"); + + // Initial state verification + classMap.IdMemberMap.Should().NotBeNull(); + classMap.GetMemberMap(c => c.Name).ElementName.Should().Be("custom_name"); + + var subject = new ResetClassMapConvention(); + + // Act + subject.Apply(classMap); + + // Assert + classMap.IdMemberMap.Should().BeNull(); + classMap.GetMemberMap(c => c.Name).Should().BeNull(); + } + + private class TestClass + { + public int Id { get; set; } + public string Name { get; set; } + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetMemberMapsConventionTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetMemberMapsConventionTests.cs new file mode 100644 index 00000000000..f5de6ec90db --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/Conventions/ResetMemberMapsConventionTests.cs @@ -0,0 +1,72 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Conventions; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.Conventions +{ + public class ResetMemberMapsConventionTests + { + [Fact] + public void Apply_should_call_reset_on_member_map() + { + // Arrange + var classMap = new BsonClassMap(); + classMap.AutoMap(); + var memberMap = classMap.GetMemberMap(c => c.Name); + memberMap.SetDefaultValue("newDefault"); + + var subject = new ResetMemberMapsConvention(); + + // Act + subject.Apply(memberMap); + + // Assert + memberMap.DefaultValue.Should().Be(null); + } + + [Fact] + public void Apply_should_reset_member_map() + { + // Arrange + var classMap = new BsonClassMap(); + var memberMap = classMap.MapProperty(c => c.Name); + memberMap.SetElementName("custom_name"); + memberMap.SetIgnoreIfNull(true); + + // Initial state verification + memberMap.ElementName.Should().Be("custom_name"); + memberMap.IgnoreIfNull.Should().BeTrue(); + + var subject = new ResetMemberMapsConvention(); + + // Act + subject.Apply(memberMap); + + // Assert + memberMap.ElementName.Should().Be("Name"); + memberMap.IgnoreIfNull.Should().BeFalse(); + } + + private class TestClass + { + public int Id { get; set; } + public string Name { get; set; } + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/IBsonSerializerExtensionsTests.cs b/tests/MongoDB.Bson.Tests/Serialization/IBsonSerializerExtensionsTests.cs new file mode 100644 index 00000000000..87e42627530 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/IBsonSerializerExtensionsTests.cs @@ -0,0 +1,202 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Serializers; +using Moq; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization +{ + public class IBsonSerializerExtensionsTests + { + [Fact] + public void ToBsonValue_generic_should_convert_value_to_BsonValue() + { + // Arrange + var serializer = new Int32Serializer(); + var value = 42; + + // Act + var result = serializer.ToBsonValue(value); + + // Assert + result.Should().BeOfType(); + result.AsInt32.Should().Be(value); + } + + [Fact] + public void ToBsonValue_generic_should_handle_complex_objects() + { + // Arrange + var serializer = new BsonDocumentSerializer(); + var document = new BsonDocument + { + { "field1", 123 }, + { "field2", "value" } + }; + + // Act + var result = serializer.ToBsonValue(document); + + // Assert + result.Should().BeOfType(); + result.AsBsonDocument.Should().Be(document); + } + + [Fact] + public void ToBsonValue_generic_should_handle_null_value() + { + // Arrange + var serializer = new StringSerializer(); + string value = null; + + // Act + var result = serializer.ToBsonValue(value); + + // Assert + result.Should().BeOfType(); + } + + [Fact] + public void ToBsonValue_generic_should_use_correct_serialization_context() + { + // Arrange + var mockSerializer = new Mock>(); + mockSerializer.Setup(s => s.ValueType).Returns(typeof(int)); + mockSerializer + .Setup(s => s.Serialize( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Callback((context, args, value) => + { + // Write a known value to verify it was called correctly + context.Writer.WriteInt32(42); + }); + + // Act + var result = mockSerializer.Object.ToBsonValue(123); + + // Assert + result.Should().BeOfType(); + result.AsInt32.Should().Be(42); + } + + [Fact] + public void ToBsonValue_generic_should_wrap_value_in_document() + { + // Arrange + var serializer = new StringSerializer(); + var value = "test"; + + // Act + var result = serializer.ToBsonValue(value); + + // Assert + result.Should().BeOfType(); + result.AsString.Should().Be(value); + } + + [Fact] + public void ToBsonValue_non_generic_should_convert_value_to_BsonValue() + { + // Arrange + var serializer = new Int32Serializer(); + var value = 42; + + // Act + var result = serializer.ToBsonValue(value); + + // Assert + result.Should().BeOfType(); + result.AsInt32.Should().Be(value); + } + + [Fact] + public void ToBsonValue_non_generic_should_handle_complex_objects() + { + // Arrange + var documentSerializer = new BsonDocumentSerializer(); + var document = new BsonDocument + { + { "field1", 123 }, + { "field2", "value" } + }; + + // Act + var result = documentSerializer.ToBsonValue(document); + + // Assert + result.Should().BeOfType(); + result.AsBsonDocument.Should().Be(document); + } + + [Fact] + public void ToBsonValue_non_generic_should_handle_null_value() + { + // Arrange + var serializer = new StringSerializer(); + string value = null; + + // Act + var result = serializer.ToBsonValue((object)value); + + // Assert + result.Should().BeOfType(); + } + + [Fact] + public void ToBsonValue_non_generic_should_use_correct_serialization_context() + { + // Arrange + var mockSerializer = new Mock(); + mockSerializer.Setup(s => s.ValueType).Returns(typeof(int)); + mockSerializer + .Setup(s => s.Serialize( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Callback((context, args, value) => + { + // Write a known value to verify it was called correctly + context.Writer.WriteInt32(42); + }); + + // Act + var result = mockSerializer.Object.ToBsonValue(123); + + // Assert + result.Should().BeOfType(); + result.AsInt32.Should().Be(42); + } + + [Fact] + public void ToBsonValue_non_generic_should_wrap_value_in_document() + { + // Arrange + var serializer = new StringSerializer(); + var value = "test"; + + // Act + var result = serializer.ToBsonValue(value); + + // Assert + result.Should().BeOfType(); + result.AsString.Should().Be(value); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonBinaryDataGuidGeneratorTests.cs b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonBinaryDataGuidGeneratorTests.cs new file mode 100644 index 00000000000..05bc13bedca --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonBinaryDataGuidGeneratorTests.cs @@ -0,0 +1,277 @@ +/* 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; +using FluentAssertions; +using MongoDB.Bson.Serialization.IdGenerators; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.IdGenerators +{ + public class BsonBinaryDataGuidGeneratorTests + { + [Fact] + public void Constructor_should_initialize_instance() + { + // Arrange + var guidRepresentation = GuidRepresentation.Standard; + + // Act + var generator = new BsonBinaryDataGuidGenerator(guidRepresentation); + + // Assert + generator.GuidRepresentation.Should().Be(guidRepresentation); + } + + [Fact] + public void CSharpLegacyInstance_should_return_singleton_with_correct_representation() + { + // Act + var instance = BsonBinaryDataGuidGenerator.CSharpLegacyInstance; + + // Assert + instance.Should().NotBeNull(); + instance.GuidRepresentation.Should().Be(GuidRepresentation.CSharpLegacy); + BsonBinaryDataGuidGenerator.CSharpLegacyInstance.Should().BeSameAs(instance); + } + + [Fact] + public void GenerateId_should_return_BsonBinaryData_with_new_guid() + { + // Arrange + var guidRepresentation = GuidRepresentation.Standard; + var generator = new BsonBinaryDataGuidGenerator(guidRepresentation); + + // Act + var id = generator.GenerateId(null, null); + + // Assert + id.Should().BeOfType(); + var binaryData = (BsonBinaryData)id; + binaryData.SubType.Should().Be(BsonBinarySubType.UuidStandard); + binaryData.Bytes.Length.Should().Be(16); + binaryData.Bytes.Should().NotEqual(Guid.Empty.ToByteArray()); + } + + [Fact] + public void GetInstance_should_return_CSharpLegacyInstance_when_CSharpLegacy() + { + // Act + var instance = BsonBinaryDataGuidGenerator.GetInstance(GuidRepresentation.CSharpLegacy); + + // Assert + instance.Should().BeSameAs(BsonBinaryDataGuidGenerator.CSharpLegacyInstance); + } + + [Fact] + public void GetInstance_should_return_JavaLegacyInstance_when_JavaLegacy() + { + // Act + var instance = BsonBinaryDataGuidGenerator.GetInstance(GuidRepresentation.JavaLegacy); + + // Assert + instance.Should().BeSameAs(BsonBinaryDataGuidGenerator.JavaLegacyInstance); + } + + [Fact] + public void GetInstance_should_return_PythonLegacyInstance_when_PythonLegacy() + { + // Act + var instance = BsonBinaryDataGuidGenerator.GetInstance(GuidRepresentation.PythonLegacy); + + // Assert + instance.Should().BeSameAs(BsonBinaryDataGuidGenerator.PythonLegacyInstance); + } + + [Fact] + public void GetInstance_should_return_StandardInstance_when_Standard() + { + // Act + var instance = BsonBinaryDataGuidGenerator.GetInstance(GuidRepresentation.Standard); + + // Assert + instance.Should().BeSameAs(BsonBinaryDataGuidGenerator.StandardInstance); + } + + [Fact] + public void GetInstance_should_return_UnspecifiedInstance_when_Unspecified() + { + // Act + var instance = BsonBinaryDataGuidGenerator.GetInstance(GuidRepresentation.Unspecified); + + // Assert + instance.Should().BeSameAs(BsonBinaryDataGuidGenerator.UnspecifedInstance); + } + + [Fact] + public void GetInstance_should_throw_for_invalid_representation() + { + // Arrange + var invalidRepresentation = (GuidRepresentation)999; + + // Act + Action act = () => BsonBinaryDataGuidGenerator.GetInstance(invalidRepresentation); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("guidRepresentation"); + } + + [Fact] + public void GuidRepresentation_property_should_return_correct_value() + { + // Arrange + var guidRepresentation = GuidRepresentation.Standard; + var generator = new BsonBinaryDataGuidGenerator(guidRepresentation); + + // Act + var result = generator.GuidRepresentation; + + // Assert + result.Should().Be(guidRepresentation); + } + + [Fact] + public void IsEmpty_should_return_false_for_non_empty_guid() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.Standard); + var guid = new BsonBinaryData(Guid.NewGuid(), GuidRepresentation.Standard); + + // Act + var result = generator.IsEmpty(guid); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void IsEmpty_should_return_true_for_BsonNull() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.Standard); + var bsonNull = BsonNull.Value; + + // Act + var result = generator.IsEmpty(bsonNull); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void IsEmpty_should_return_true_for_empty_guid_legacy() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.CSharpLegacy); + var emptyGuid = new BsonBinaryData(Guid.Empty, GuidRepresentation.CSharpLegacy); + + // Act + var result = generator.IsEmpty(emptyGuid); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void IsEmpty_should_return_true_for_empty_guid_standard() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.Standard); + var emptyGuid = new BsonBinaryData(Guid.Empty, GuidRepresentation.Standard); + + // Act + var result = generator.IsEmpty(emptyGuid); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void IsEmpty_should_return_true_for_null() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.Standard); + + // Act + var result = generator.IsEmpty(null); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void IsEmpty_should_throw_for_invalid_binary_subtype() + { + // Arrange + var generator = new BsonBinaryDataGuidGenerator(GuidRepresentation.Standard); + var invalidId = new BsonBinaryData(new byte[] { 1, 2, 3 }, BsonBinarySubType.Binary); + + // Act + Action act = () => generator.IsEmpty(invalidId); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("id"); + } + + [Fact] + public void JavaLegacyInstance_should_return_singleton_with_correct_representation() + { + // Act + var instance = BsonBinaryDataGuidGenerator.JavaLegacyInstance; + + // Assert + instance.Should().NotBeNull(); + instance.GuidRepresentation.Should().Be(GuidRepresentation.JavaLegacy); + BsonBinaryDataGuidGenerator.JavaLegacyInstance.Should().BeSameAs(instance); + } + + [Fact] + public void PythonLegacyInstance_should_return_singleton_with_correct_representation() + { + // Act + var instance = BsonBinaryDataGuidGenerator.PythonLegacyInstance; + + // Assert + instance.Should().NotBeNull(); + instance.GuidRepresentation.Should().Be(GuidRepresentation.PythonLegacy); + BsonBinaryDataGuidGenerator.PythonLegacyInstance.Should().BeSameAs(instance); + } + + [Fact] + public void StandardInstance_should_return_singleton_with_correct_representation() + { + // Act + var instance = BsonBinaryDataGuidGenerator.StandardInstance; + + // Assert + instance.Should().NotBeNull(); + instance.GuidRepresentation.Should().Be(GuidRepresentation.Standard); + BsonBinaryDataGuidGenerator.StandardInstance.Should().BeSameAs(instance); + } + + [Fact] + public void UnspecifiedInstance_should_return_singleton_with_correct_representation() + { + // Act + var instance = BsonBinaryDataGuidGenerator.UnspecifedInstance; + + // Assert + instance.Should().NotBeNull(); + instance.GuidRepresentation.Should().Be(GuidRepresentation.Unspecified); + BsonBinaryDataGuidGenerator.UnspecifedInstance.Should().BeSameAs(instance); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonObjectIdGeneratorTests.cs b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonObjectIdGeneratorTests.cs new file mode 100644 index 00000000000..aa16187a445 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/BsonObjectIdGeneratorTests.cs @@ -0,0 +1,110 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization.IdGenerators; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.IdGenerators +{ + public class BsonObjectIdGeneratorTests + { + [Fact] + public void GenerateId_should_create_new_BsonObjectId_with_unique_ObjectId() + { + // Arrange + var generator = new BsonObjectIdGenerator(); + + // Act + var result1 = generator.GenerateId(null, null); + var result2 = generator.GenerateId(null, null); + + // Assert + result1.Should().BeOfType(); + result2.Should().BeOfType(); + result1.Should().NotBeSameAs(result2); + ((BsonObjectId)result1).Value.Should().NotBe(ObjectId.Empty); + ((BsonObjectId)result2).Value.Should().NotBe(ObjectId.Empty); + ((BsonObjectId)result1).Value.Should().NotBe(((BsonObjectId)result2).Value); + } + + [Fact] + public void Instance_should_return_singleton_instance() + { + // Act + var instance1 = BsonObjectIdGenerator.Instance; + var instance2 = BsonObjectIdGenerator.Instance; + + // Assert + instance1.Should().NotBeNull(); + instance1.Should().BeSameAs(instance2); + } + + [Fact] + public void IsEmpty_should_return_false_when_id_contains_non_empty_ObjectId() + { + // Arrange + var generator = new BsonObjectIdGenerator(); + var id = new BsonObjectId(ObjectId.GenerateNewId()); + + // Act + var result = generator.IsEmpty(id); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void IsEmpty_should_return_true_when_id_contains_ObjectId_Empty() + { + // Arrange + var generator = new BsonObjectIdGenerator(); + var id = new BsonObjectId(ObjectId.Empty); + + // Act + var result = generator.IsEmpty(id); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void IsEmpty_should_return_true_when_id_is_BsonNull() + { + // Arrange + var generator = new BsonObjectIdGenerator(); + var id = BsonNull.Value; + + // Act + var result = generator.IsEmpty(id); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void IsEmpty_should_return_true_when_id_is_null() + { + // Arrange + var generator = new BsonObjectIdGenerator(); + + // Act + var result = generator.IsEmpty(null); + + // Assert + result.Should().BeTrue(); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/StringObjectIdGeneratorTests.cs b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/StringObjectIdGeneratorTests.cs new file mode 100644 index 00000000000..59ef01737bc --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/IdGenerators/StringObjectIdGeneratorTests.cs @@ -0,0 +1,98 @@ +/* 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 FluentAssertions; +using MongoDB.Bson.Serialization.IdGenerators; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.IdGenerators +{ + public class StringObjectIdGeneratorTests + { + [Fact] + public void GenerateId_should_create_unique_ids_on_multiple_calls() + { + // Arrange + var generator = new StringObjectIdGenerator(); + + // Act + var result1 = (string)generator.GenerateId(null, null); + var result2 = (string)generator.GenerateId(null, null); + + // Assert + result1.Should().NotBe(result2); + ObjectId.Parse(result1).Should().NotBe(ObjectId.Parse(result2)); + } + + [Fact] + public void GenerateId_should_return_string_representation_of_new_ObjectId() + { + // Arrange + var generator = new StringObjectIdGenerator(); + + // Act + var result = generator.GenerateId(null, null); + + // Assert + result.Should().BeOfType(); + var resultString = (string)result; + resultString.Should().NotBeNullOrEmpty(); + resultString.Length.Should().Be(24); // ObjectId string representation length + ObjectId.TryParse(resultString, out var objectId).Should().BeTrue(); + objectId.Should().NotBe(ObjectId.Empty); + } + + [Fact] + public void Instance_should_return_singleton_instance() + { + // Act + var instance1 = StringObjectIdGenerator.Instance; + var instance2 = StringObjectIdGenerator.Instance; + + // Assert + instance1.Should().NotBeNull(); + instance1.Should().BeSameAs(instance2); + } + + [Fact] + public void IsEmpty_should_return_false_when_id_is_not_empty() + { + // Arrange + var generator = new StringObjectIdGenerator(); + var id = ObjectId.GenerateNewId().ToString(); + + // Act + var result = generator.IsEmpty(id); + + // Assert + result.Should().BeFalse(); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + public void IsEmpty_should_return_true_when_id_is_null_or_empty(string id) + { + // Arrange + var generator = new StringObjectIdGenerator(); + + // Act + var result = generator.IsEmpty(id); + + // Assert + result.Should().BeTrue(); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueCSharpValueNullSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueCSharpValueNullSerializerTests.cs index a339f97177a..81a8e43a978 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueCSharpValueNullSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueCSharpValueNullSerializerTests.cs @@ -13,29 +13,34 @@ * limitations under the License. */ -using System; using FluentAssertions; +using Moq; using Xunit; namespace MongoDB.Bson.Serialization.Serializers { - public class BsonValueCSharpNullSerializerTests + public class BsonValueCSharpNullArrayAndDocumentSerializerTests { [Fact] - public void Equals_derived_should_return_false() + public void Constructor_should_initialize_instance() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); - var y = new DerivedFromBsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + // Arrange + var wrappedSerializer = new Mock>().Object; - var result = x.Equals(y); + // Act + var subject = new BsonValueCSharpNullArrayAndDocumentSerializer(wrappedSerializer); - result.Should().Be(false); + // Assert + subject.Should().NotBeNull(); + subject.Should().BeAssignableTo>(); + subject.Should().BeAssignableTo(); + subject.Should().BeAssignableTo(); } [Fact] public void Equals_null_should_return_false() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(null); @@ -45,7 +50,7 @@ public void Equals_null_should_return_false() [Fact] public void Equals_object_should_return_false() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); var y = new object(); var result = x.Equals(y); @@ -56,7 +61,7 @@ public void Equals_object_should_return_false() [Fact] public void Equals_self_should_return_true() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(x); @@ -66,8 +71,8 @@ public void Equals_self_should_return_true() [Fact] public void Equals_with_equal_fields_should_return_true() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); - var y = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var y = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(y); @@ -77,8 +82,8 @@ public void Equals_with_equal_fields_should_return_true() [Fact] public void Equals_with_not_equal_field_should_return_false() { - var x = new BsonValueCSharpNullSerializer(new BsonValueSerializer1()); - var y = new BsonValueCSharpNullSerializer(new BsonValueSerializer2()); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(new BsonValueSerializer1()); + var y = new BsonValueCSharpNullArrayAndDocumentSerializer(new BsonValueSerializer2()); var result = x.Equals(y); @@ -88,29 +93,94 @@ public void Equals_with_not_equal_field_should_return_false() [Fact] public void GetHashCode_should_return_zero() { - var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); var result = x.GetHashCode(); result.Should().Be(0); } - public class DerivedFromBsonValueCSharpNullSerializer : BsonValueCSharpNullSerializer - where TBsonValue : BsonValue + [Fact] + public void TryGetItemSerializationInfo_should_delegate_to_BsonValueSerializer() { - public DerivedFromBsonValueCSharpNullSerializer(IBsonSerializer wrappedSerializer) - : base(wrappedSerializer) + // Arrange + var wrappedSerializer = new Mock>().Object; + var subject = new BsonValueCSharpNullArrayAndDocumentSerializer(wrappedSerializer); + + // Get expected result directly from BsonValueSerializer for comparison + bool expectedResult = BsonValueSerializer.Instance.TryGetItemSerializationInfo(out BsonSerializationInfo expectedInfo); + + // Act + bool result = subject.TryGetItemSerializationInfo(out BsonSerializationInfo actualInfo); + + // Assert + result.Should().Be(expectedResult); + + if (expectedResult) { + actualInfo.Should().NotBeNull(); + actualInfo.ElementName.Should().Be(expectedInfo.ElementName); + actualInfo.NominalType.Should().Be(expectedInfo.NominalType); + actualInfo.Serializer.Should().BeSameAs(expectedInfo.Serializer); + } + } + + [Fact] + public void TryGetMemberSerializationInfo_should_delegate_to_BsonValueSerializer() + { + // Arrange + var wrappedSerializer = new Mock>().Object; + var subject = new BsonValueCSharpNullArrayAndDocumentSerializer(wrappedSerializer); + string memberName = "testMember"; + + // Get expected result directly from BsonValueSerializer for comparison + bool expectedResult = BsonValueSerializer.Instance.TryGetMemberSerializationInfo(memberName, out BsonSerializationInfo expectedInfo); + + // Act + bool result = subject.TryGetMemberSerializationInfo(memberName, out BsonSerializationInfo actualInfo); + + // Assert + result.Should().Be(expectedResult); + + if (expectedResult) + { + actualInfo.Should().NotBeNull(); + actualInfo.ElementName.Should().Be(expectedInfo.ElementName); + actualInfo.NominalType.Should().Be(expectedInfo.NominalType); + actualInfo.Serializer.Should().BeSameAs(expectedInfo.Serializer); + } + } + + [Fact] + public void TryGetMemberSerializationInfo_with_different_member_names_should_behave_like_BsonValueSerializer() + { + // Arrange + var wrappedSerializer = new Mock>().Object; + var subject = new BsonValueCSharpNullArrayAndDocumentSerializer(wrappedSerializer); + + // Test with several different member names + var memberNames = new[] { "member1", "property2", "_id", "123", string.Empty }; + + foreach (var memberName in memberNames) + { + // Get expected result from BsonValueSerializer for comparison + bool expectedResult = BsonValueSerializer.Instance.TryGetMemberSerializationInfo(memberName, out _); + + // Act + bool actualResult = subject.TryGetMemberSerializationInfo(memberName, out _); + + // Assert + actualResult.Should().Be(expectedResult, $"because result for member name '{memberName}' should match BsonValueSerializer's behavior"); } } } - public class BsonValueCSharpNullArrayAndDocumentSerializerTests + public class BsonValueCSharpNullArraySerializerTests { [Fact] public void Equals_null_should_return_false() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); var result = x.Equals(null); @@ -120,7 +190,7 @@ public void Equals_null_should_return_false() [Fact] public void Equals_object_should_return_false() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); var y = new object(); var result = x.Equals(y); @@ -131,7 +201,7 @@ public void Equals_object_should_return_false() [Fact] public void Equals_self_should_return_true() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); var result = x.Equals(x); @@ -141,8 +211,8 @@ public void Equals_self_should_return_true() [Fact] public void Equals_with_equal_fields_should_return_true() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); - var y = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var y = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); var result = x.Equals(y); @@ -152,8 +222,8 @@ public void Equals_with_equal_fields_should_return_true() [Fact] public void Equals_with_not_equal_field_should_return_false() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(new BsonValueSerializer1()); - var y = new BsonValueCSharpNullArrayAndDocumentSerializer(new BsonValueSerializer2()); + var x = new BsonValueCSharpNullArraySerializer(new BsonValueSerializer1()); + var y = new BsonValueCSharpNullArraySerializer(new BsonValueSerializer2()); var result = x.Equals(y); @@ -163,7 +233,7 @@ public void Equals_with_not_equal_field_should_return_false() [Fact] public void GetHashCode_should_return_zero() { - var x = new BsonValueCSharpNullArrayAndDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); var result = x.GetHashCode(); @@ -171,12 +241,12 @@ public void GetHashCode_should_return_zero() } } - public class BsonValueCSharpNullArraySerializerTests + public class BsonValueCSharpNullDocumentSerializerTests { [Fact] public void Equals_null_should_return_false() { - var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(null); @@ -186,7 +256,7 @@ public void Equals_null_should_return_false() [Fact] public void Equals_object_should_return_false() { - var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); var y = new object(); var result = x.Equals(y); @@ -197,7 +267,7 @@ public void Equals_object_should_return_false() [Fact] public void Equals_self_should_return_true() { - var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(x); @@ -207,8 +277,8 @@ public void Equals_self_should_return_true() [Fact] public void Equals_with_equal_fields_should_return_true() { - var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); - var y = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var y = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); var result = x.Equals(y); @@ -218,8 +288,8 @@ public void Equals_with_equal_fields_should_return_true() [Fact] public void Equals_with_not_equal_field_should_return_false() { - var x = new BsonValueCSharpNullArraySerializer(new BsonValueSerializer1()); - var y = new BsonValueCSharpNullArraySerializer(new BsonValueSerializer2()); + var x = new BsonValueCSharpNullDocumentSerializer(new BsonValueSerializer1()); + var y = new BsonValueCSharpNullDocumentSerializer(new BsonValueSerializer2()); var result = x.Equals(y); @@ -229,7 +299,7 @@ public void Equals_with_not_equal_field_should_return_false() [Fact] public void GetHashCode_should_return_zero() { - var x = new BsonValueCSharpNullArraySerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); var result = x.GetHashCode(); @@ -237,12 +307,23 @@ public void GetHashCode_should_return_zero() } } - public class BsonValueCSharpNullDocumentSerializerTests + public class BsonValueCSharpNullSerializerTests { + [Fact] + public void Equals_derived_should_return_false() + { + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var y = new DerivedFromBsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + + var result = x.Equals(y); + + result.Should().Be(false); + } + [Fact] public void Equals_null_should_return_false() { - var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); var result = x.Equals(null); @@ -252,7 +333,7 @@ public void Equals_null_should_return_false() [Fact] public void Equals_object_should_return_false() { - var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); var y = new object(); var result = x.Equals(y); @@ -263,7 +344,7 @@ public void Equals_object_should_return_false() [Fact] public void Equals_self_should_return_true() { - var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); var result = x.Equals(x); @@ -273,8 +354,8 @@ public void Equals_self_should_return_true() [Fact] public void Equals_with_equal_fields_should_return_true() { - var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); - var y = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); + var y = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); var result = x.Equals(y); @@ -284,8 +365,8 @@ public void Equals_with_equal_fields_should_return_true() [Fact] public void Equals_with_not_equal_field_should_return_false() { - var x = new BsonValueCSharpNullDocumentSerializer(new BsonValueSerializer1()); - var y = new BsonValueCSharpNullDocumentSerializer(new BsonValueSerializer2()); + var x = new BsonValueCSharpNullSerializer(new BsonValueSerializer1()); + var y = new BsonValueCSharpNullSerializer(new BsonValueSerializer2()); var result = x.Equals(y); @@ -295,15 +376,25 @@ public void Equals_with_not_equal_field_should_return_false() [Fact] public void GetHashCode_should_return_zero() { - var x = new BsonValueCSharpNullDocumentSerializer(BsonValueSerializer.Instance); + var x = new BsonValueCSharpNullSerializer(BsonValueSerializer.Instance); var result = x.GetHashCode(); result.Should().Be(0); } - } - public class BsonValueSerializer1 : SerializerBase { } + public class DerivedFromBsonValueCSharpNullSerializer : BsonValueCSharpNullSerializer + where TBsonValue : BsonValue + { + public DerivedFromBsonValueCSharpNullSerializer(IBsonSerializer wrappedSerializer) + : base(wrappedSerializer) + { + } + } + } + public class BsonValueSerializer1 : SerializerBase + { } - public class BsonValueSerializer2 : SerializerBase { } + public class BsonValueSerializer2 : SerializerBase + { } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueSerializerBaseTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueSerializerBaseTests.cs index ca2ccbea041..8143acdf90e 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueSerializerBaseTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/BsonValueSerializerBaseTests.cs @@ -13,16 +13,78 @@ * limitations under the License. */ +using System; using FluentAssertions; +using MongoDB.Bson.IO; using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; using MongoDB.Bson.TestHelpers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers { public class BsonValueSerializerBaseTests { + [Fact] + public void DeserializeValue_should_delegate_to_appropriate_serializer_based_on_bson_type() + { + // Since we can't directly call the protected DeserializeValue method, we'll test through the public Deserialize method + // We'll test with a few representative BsonTypes + + // Arrange - Int32 + var int32Value = 42; + var int32Document = new BsonDocument("value", int32Value); + using var int32Reader = new BsonDocumentReader(int32Document); + int32Reader.ReadStartDocument(); + int32Reader.ReadName("value"); + var int32Context = BsonDeserializationContext.CreateRoot(int32Reader); + var int32Args = new BsonDeserializationArgs(); + + // Act - Int32 + var int32Result = BsonValueSerializer.Instance.Deserialize(int32Context, int32Args); + + // Assert - Int32 + int32Result.Should().BeOfType(); + int32Result.AsInt32.Should().Be(int32Value); + int32Reader.ReadEndDocument(); + + // Arrange - String + var stringValue = "test"; + var stringDocument = new BsonDocument("value", stringValue); + using var stringReader = new BsonDocumentReader(stringDocument); + stringReader.ReadStartDocument(); + stringReader.ReadName("value"); + var stringContext = BsonDeserializationContext.CreateRoot(stringReader); + var stringArgs = new BsonDeserializationArgs(); + + // Act - String + var stringResult = BsonValueSerializer.Instance.Deserialize(stringContext, stringArgs); + + // Assert - String + stringResult.Should().BeOfType(); + stringResult.AsString.Should().Be(stringValue); + stringReader.ReadEndDocument(); + + // Arrange - Document + var documentValue = new BsonDocument("nested", "value"); + var document = new BsonDocument("value", documentValue); + using var documentReader = new BsonDocumentReader(document); + documentReader.ReadStartDocument(); + documentReader.ReadName("value"); + var documentContext = BsonDeserializationContext.CreateRoot(documentReader); + var documentArgs = new BsonDeserializationArgs(); + + // Act - Document + var documentResult = BsonValueSerializer.Instance.Deserialize(documentContext, documentArgs); + + // Assert - Document + documentResult.Should().BeOfType(); + documentResult.AsBsonDocument.Should().NotBeNull(); + documentResult.AsBsonDocument["nested"].AsString.Should().Be("value"); + documentReader.ReadEndDocument(); + } + [Fact] public void Equals_derived_should_return_false() { @@ -86,19 +148,141 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + [Fact] + public void SerializeValue_should_delegate_to_appropriate_serializer_based_on_bson_value_type() + { + // We'll test a few representative BsonValue types + + // Arrange - Int32 + var int32Value = new BsonInt32(42); + var int32Document = new BsonDocument(); + using var int32Writer = new BsonDocumentWriter(int32Document); + int32Writer.WriteStartDocument(); + int32Writer.WriteName("value"); + var int32Context = BsonSerializationContext.CreateRoot(int32Writer); + var int32Args = new BsonSerializationArgs(); + + // Act - Int32 + BsonValueSerializer.Instance.Serialize(int32Context, int32Args, int32Value); + + // Complete the document + int32Writer.WriteEndDocument(); + + // Assert - Int32 + int32Document.Should().NotBeNull(); + int32Document["value"].Should().Be(int32Value); + + // Arrange - String + var stringValue = new BsonString("test"); + var stringDocument = new BsonDocument(); + using var stringWriter = new BsonDocumentWriter(stringDocument); + stringWriter.WriteStartDocument(); + stringWriter.WriteName("value"); + var stringContext = BsonSerializationContext.CreateRoot(stringWriter); + var stringArgs = new BsonSerializationArgs(); + + // Act - String + BsonValueSerializer.Instance.Serialize(stringContext, stringArgs, stringValue); + + // Complete the document + stringWriter.WriteEndDocument(); + + // Assert - String + stringDocument.Should().NotBeNull(); + stringDocument["value"].Should().Be(stringValue); + + // Arrange - Document + var nestedDocument = new BsonDocument("nested", "value"); + var documentValue = nestedDocument; + var document = new BsonDocument(); + using var documentWriter = new BsonDocumentWriter(document); + documentWriter.WriteStartDocument(); + documentWriter.WriteName("value"); + var documentContext = BsonSerializationContext.CreateRoot(documentWriter); + var documentArgs = new BsonSerializationArgs(); + + // Act - Document + BsonValueSerializer.Instance.Serialize(documentContext, documentArgs, documentValue); + + // Complete the document + documentWriter.WriteEndDocument(); + + // Assert - Document + document.Should().NotBeNull(); + document["value"].Should().BeOfType(); + document["value"].AsBsonDocument["nested"].AsString.Should().Be("value"); + } + + [Fact] + public void SerializeValue_should_throw_for_invalid_bson_value_type() + { + // Arrange + var mockBsonValue = new Mock(); + mockBsonValue.Setup(v => v.BsonType).Returns((BsonType)999); // Invalid BsonType + + var document = new BsonDocument(); + using var writer = new BsonDocumentWriter(document); + writer.WriteStartDocument(); + writer.WriteName("value"); + var context = BsonSerializationContext.CreateRoot(writer); + var args = new BsonSerializationArgs() { SerializeAsNominalType = true }; + + // Act + Action act = () => BsonValueSerializer.Instance.Serialize(context, args, mockBsonValue.Object); + + // Assert + act.ShouldThrow() + .WithMessage("Invalid BsonType."); + } + + [Fact] + public void TryGetItemSerializationInfo_should_return_true_and_correct_info() + { + // Arrange & Act + var result = BsonValueSerializer.Instance.TryGetItemSerializationInfo(out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().NotBeNull(); + serializationInfo.ElementName.Should().BeNull(); + serializationInfo.Serializer.Should().BeSameAs(BsonValueSerializer.Instance); + serializationInfo.NominalType.Should().Be(typeof(BsonValue)); + } + + [Fact] + public void TryGetMemberSerializationInfo_should_return_true_and_correct_info() + { + // Arrange + var memberName = "testMember"; + + // Act + var result = BsonValueSerializer.Instance.TryGetMemberSerializationInfo(memberName, out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().NotBeNull(); + serializationInfo.ElementName.Should().Be(memberName); + serializationInfo.Serializer.Should().BeSameAs(BsonValueSerializer.Instance); + serializationInfo.NominalType.Should().Be(typeof(BsonValue)); + } public class ConcreteBsonValueSerializerBase : BsonValueSerializerBase where TBsonValue : BsonValue { - public ConcreteBsonValueSerializerBase(BsonType representation) : base(representation) { } + public ConcreteBsonValueSerializerBase(BsonType representation) : base(representation) + { + } protected override TBsonValue DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args) => throw new System.NotImplementedException(); + protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, TBsonValue value) => throw new System.NotImplementedException(); } public class DerivedFromConcreteBsonValueSerializerBase : ConcreteBsonValueSerializerBase where TBsonValue : BsonValue { - public DerivedFromConcreteBsonValueSerializerBase(BsonType representation) : base(representation) { } + public DerivedFromConcreteBsonValueSerializerBase(BsonType representation) : base(representation) + { + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/DictionaryGenericSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/DictionaryGenericSerializerTests.cs index f06d3b1062b..45f8dfa266d 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/DictionaryGenericSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/DictionaryGenericSerializerTests.cs @@ -20,16 +20,16 @@ using System.IO; using System.Linq; using System.Text; +using FluentAssertions; using MongoDB.Bson.IO; using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Attributes; using MongoDB.Bson.Serialization.Options; using MongoDB.Bson.Serialization.Serializers; using MongoDB.Bson.TestHelpers; -using MongoDB.TestHelpers.XunitExtensions; using Xunit; -namespace MongoDB.Bson.Tests.Serialization.DictionaryGenericSerializers +namespace MongoDB.Bson.Tests.Serialization.Serializers { [BsonDiscriminator("DictionaryGenericSerializers.C")] // "C" is an ambiguous discriminator when nominalType is System.Object public class C @@ -66,50 +66,182 @@ static DictionaryGenericSerializerTests() }); } - public class T + [Fact] + public void Constructor_with_dictionary_representation_and_serializers_should_initialize_instance() { - public Dictionary D { get; set; } - public IDictionary ID { get; set; } - public IReadOnlyDictionary IROD { get; set; } - public ReadOnlyDictionary ROD { get; set; } - public SortedDictionary SD { get; set; } - public SortedList SL { get; set; } + // Arrange + var dictionaryRepresentation = DictionaryRepresentation.ArrayOfDocuments; + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + + // Act + var subject = new DictionaryInterfaceImplementerSerializer>( + dictionaryRepresentation, keySerializer, valueSerializer); + + // Assert + subject.Should().NotBeNull(); + subject.DictionaryRepresentation.Should().Be(dictionaryRepresentation); + subject.KeySerializer.Should().BeSameAs(keySerializer); + subject.ValueSerializer.Should().BeSameAs(valueSerializer); } - public class RO : ReadOnlyDictionary + [Fact] + public void Constructor_with_dictionary_representation_should_initialize_instance() { - private RO(IDictionary dictionary) : base(dictionary) - { - } + // Arrange + var dictionaryRepresentation = DictionaryRepresentation.ArrayOfDocuments; - public static RO ConstructorReplacement(IDictionary dictionary) - { - return new RO(dictionary); - } + // Act + var subject = new DictionaryInterfaceImplementerSerializer>(dictionaryRepresentation); + + // Assert + subject.Should().NotBeNull(); + subject.DictionaryRepresentation.Should().Be(dictionaryRepresentation); + subject.KeySerializer.Should().NotBeNull(); + subject.ValueSerializer.Should().NotBeNull(); } [Fact] - public void TestNull() + public void Constructor_with_no_arguments_should_initialize_instance() { - var obj = new T { D = null, ID = null, IROD = null, ROD = null, SD = null, SL = null }; - var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var rep = "null"; + // Act + var subject = new DictionaryInterfaceImplementerSerializer>(); - var expected = "{ 'D' : #R, 'ID' : #R, 'IROD' : #R, 'ROD' : #R, 'SD' : #R, 'SL' : #R }".Replace("#R", rep).Replace("'", "\""); - // 'IROD' : #R, 'ROD' : #R, + // Assert + subject.Should().NotBeNull(); + subject.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + subject.KeySerializer.Should().NotBeNull(); + subject.ValueSerializer.Should().NotBeNull(); + } - Assert.Equal(expected, json); + [Fact] + public void IChildSerializerConfigurable_ChildSerializer_should_return_ValueSerializer() + { + // Arrange + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, new StringSerializer(), valueSerializer); + var configurable = (IChildSerializerConfigurable)subject; - var bson = obj.ToBson(); - var rehydrated = BsonSerializer.Deserialize(bson); - Assert.Null(rehydrated.D); - Assert.Null(rehydrated.ID); - Assert.Null(rehydrated.IROD); - Assert.Null(rehydrated.ROD); - Assert.Null(rehydrated.SD); - Assert.Null(rehydrated.SL); + // Act + var result = configurable.ChildSerializer; - Assert.True(bson.SequenceEqual(rehydrated.ToBson())); + // Assert + result.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void IChildSerializerConfigurable_WithChildSerializer_should_return_new_instance_with_value_serializer_set() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var valueSerializer2 = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, valueSerializer1); + var configurable = (IChildSerializerConfigurable)subject; + + // Act + var result = configurable.WithChildSerializer(valueSerializer2); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType>>(); + var typedResult = (DictionaryInterfaceImplementerSerializer>)result; + typedResult.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + typedResult.KeySerializer.Should().BeSameAs(keySerializer); + typedResult.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void IDictionaryRepresentationConfigurable_WithDictionaryRepresentation_should_return_new_instance() + { + // Arrange + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document); + var configurable = (IDictionaryRepresentationConfigurable)subject; + + // Act + var result = configurable.WithDictionaryRepresentation(DictionaryRepresentation.ArrayOfDocuments); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType>>(); + var typedResult = (DictionaryInterfaceImplementerSerializer>)result; + typedResult.DictionaryRepresentation.Should().Be(DictionaryRepresentation.ArrayOfDocuments); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_ChildSerializers_should_return_key_and_value_serializers() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + var configurable = (IMultipleChildSerializersConfigurable)subject; + + // Act + var result = configurable.ChildSerializers; + + // Assert + result.Should().HaveCount(2); + result[0].Should().BeSameAs(keySerializer); + result[1].Should().BeSameAs(valueSerializer); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_return_new_instance() + { + // Arrange + var keySerializer1 = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var keySerializer2 = new StringSerializer(); + var valueSerializer2 = new Int32Serializer(BsonType.String); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer1, valueSerializer1); + var configurable = (IMultipleChildSerializersConfigurable)subject; + + // Act + var result = configurable.WithChildSerializers([keySerializer2, valueSerializer2]); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType>>(); + var typedResult = (DictionaryInterfaceImplementerSerializer>)result; + typedResult.KeySerializer.Should().BeSameAs(keySerializer2); + typedResult.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_return_same_instance_when_serializers_are_equal() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + var configurable = (IMultipleChildSerializersConfigurable)subject; + + // Act + var result = configurable.WithChildSerializers([keySerializer, valueSerializer]); + + // Assert + result.Should().BeSameAs(subject); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_throw_when_number_of_serializers_is_wrong() + { + // Arrange + var subject = new DictionaryInterfaceImplementerSerializer>(); + var configurable = (IMultipleChildSerializersConfigurable)subject; + + // Act + Action act = () => configurable.WithChildSerializers([new StringSerializer()]); + + // Assert + act.ShouldThrow().WithMessage("Wrong number of child serializers passed."); } [Fact] @@ -137,6 +269,164 @@ public void TestEmpty() Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } + [Fact] + public void TestImmutablePrivateConstructorDictionaryImplementation() + { + var d = new Dictionary { { "A", new C { P = "x" } } }; + var id = RO.ConstructorReplacement(d); + var irod = new ReadOnlyDictionary(d); + var rod = new ReadOnlyDictionary(d); + var sd = CreateSortedDictionary(d); + var sl = CreateSortedList(d); + var obj = new T { D = d, ID = id, IROD = irod, ROD = rod, SD = sd, SL = sl }; + var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); + var rep = "{ 'A' : { '_t' : 'DictionaryGenericSerializers.C', 'P' : 'x' } }"; + var expected = "{ 'D' : #R, 'ID' : #R, 'IROD' : #R, 'ROD' : #R, 'SD' : #R, 'SL' : #R }".Replace("#R", rep).Replace("'", "\""); + Assert.Equal(expected, json); + + var bson = obj.ToBson(); + var rehydrated = BsonSerializer.Deserialize(bson); + Assert.IsType>(rehydrated.D); + Assert.IsType>(rehydrated.ID); + Assert.IsType>(rehydrated.IROD); + Assert.IsType>(rehydrated.ROD); + Assert.IsType>(rehydrated.SD); + Assert.IsType>(rehydrated.SL); + Assert.True(bson.SequenceEqual(rehydrated.ToBson())); + } + + [Fact] + public void TestMixedPrimitiveTypes() + { + var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); + var isoDate = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFZ", CultureInfo.InvariantCulture); + var guid = Guid.Empty; + string expectedGuidJson = null; + var objectId = ObjectId.Empty; + var d = new Dictionary + { + { "A", true }, + { "B", dateTime }, + { "C", 1.5 }, + { "D", 1 }, + { "E", 2L }, + { "G", objectId }, + { "H", "x" } + }; + if (expectedGuidJson != null) + { + d.Add("F", guid); + } + var rod = new ReadOnlyDictionary(d); + var sd = CreateSortedDictionary(d); + var sl = CreateSortedList(d); + var obj = new T { D = d, ID = d, IROD = rod, ROD = rod, SD = sd, SL = sl }; + var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); + var reps = new Dictionary + { + { "A", "true" }, + { "B", string.Format("ISODate('{0}')", isoDate) }, + { "C", "1.5" }, + { "D", "1" }, + { "E", "NumberLong(2)" }, + { "G", "ObjectId('000000000000000000000000')" }, + { "H", "'x'" } + }; + if (expectedGuidJson != null) + { + reps.Add("F", expectedGuidJson); + } + var htRep = GetDocumentRepresentationInKeyOrder(d, reps); + var sdRep = GetDocumentRepresentationInKeyOrder(sd, reps); + var slRep = GetDocumentRepresentationInKeyOrder(sl, reps); + var expected = "{ 'D' : #D, 'ID' : #D, 'IROD' : #D, 'ROD' : #D, 'SD' : #SD, 'SL' : #SL }" + .Replace("#D", htRep) + .Replace("#SD", sdRep) + .Replace("#SL", slRep) + .Replace("'", "\""); + Assert.Equal(expected, json); + + var bson = obj.ToBson(writerSettings: new BsonBinaryWriterSettings()); + var rehydrated = BsonSerializer.Deserialize(new BsonBinaryReader(new MemoryStream(bson), new BsonBinaryReaderSettings())); + Assert.IsType>(rehydrated.D); + Assert.IsType>(rehydrated.ID); + Assert.IsType>(rehydrated.IROD); + Assert.IsType>(rehydrated.ROD); + Assert.IsType>(rehydrated.SD); + Assert.IsType>(rehydrated.SL); + Assert.True(bson.SequenceEqual(rehydrated.ToBson(writerSettings: new BsonBinaryWriterSettings()))); + } + + [Fact] + public void TestMixedPrimitiveTypesWithIntKeys() + { + var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); + var guid = Guid.Empty; + var objectId = ObjectId.Empty; + var d = new Dictionary + { + { 1, true }, + { 2, dateTime }, + { 3, 1.5 }, + { 4, 1 }, + { 5, 2L }, + { 6, guid }, + { 7, objectId }, + { 8, "x" } + }; + var rod = new ReadOnlyDictionary(d); + var sd = CreateSortedDictionary(d); + var sl = CreateSortedList(d); + var obj = new T { D = d, ID = d, IROD = rod, ROD = rod, SD = sd, SL = sl }; + Assert.Throws(() => obj.ToBson()); + } + + [Fact] + public void TestMixedPrimitiveTypesWithMixedKeys() + { + // note: no SortedDictionary or SortedList in this test because you can't sort a set of keys that have mixed types + var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); + var guid = Guid.Empty; + var objectId = ObjectId.Empty; + var d = new Dictionary + { + { "A", true }, + { "B", dateTime }, + { "C", 1.5 }, + { "D", 1 }, + { 4, 2L }, + { 5.0, guid }, + { true, objectId }, + { false, "x" } + }; + var obj = new T { D = d, ID = d, SD = null, SL = null }; + Assert.Throws(() => obj.ToBson()); + } + + [Fact] + public void TestNull() + { + var obj = new T { D = null, ID = null, IROD = null, ROD = null, SD = null, SL = null }; + var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); + var rep = "null"; + + var expected = "{ 'D' : #R, 'ID' : #R, 'IROD' : #R, 'ROD' : #R, 'SD' : #R, 'SL' : #R }".Replace("#R", rep).Replace("'", "\""); + // 'IROD' : #R, 'ROD' : #R, + + Assert.Equal(expected, json); + + var bson = obj.ToBson(); + var rehydrated = BsonSerializer.Deserialize(bson); + Assert.Null(rehydrated.D); + Assert.Null(rehydrated.ID); + Assert.Null(rehydrated.IROD); + Assert.Null(rehydrated.ROD); + Assert.Null(rehydrated.SD); + Assert.Null(rehydrated.SL); + + Assert.True(bson.SequenceEqual(rehydrated.ToBson())); + } + [Fact] public void TestOneC() { @@ -370,137 +660,135 @@ public void TestTwoStringsWithIntKeys() } [Fact] - public void TestMixedPrimitiveTypes() + public void WithDictionaryRepresentation_with_different_representation_should_return_new_instance() { - var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); - var isoDate = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFZ", CultureInfo.InvariantCulture); - var guid = Guid.Empty; - string expectedGuidJson = null; - var objectId = ObjectId.Empty; - var d = new Dictionary - { - { "A", true }, - { "B", dateTime }, - { "C", 1.5 }, - { "D", 1 }, - { "E", 2L }, - { "G", objectId }, - { "H", "x" } - }; - if (expectedGuidJson != null) - { - d.Add("F", guid); - } - var rod = new ReadOnlyDictionary(d); - var sd = CreateSortedDictionary(d); - var sl = CreateSortedList(d); - var obj = new T { D = d, ID = d, IROD = rod, ROD = rod, SD = sd, SL = sl }; - var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var reps = new Dictionary - { - { "A", "true" }, - { "B", string.Format("ISODate('{0}')", isoDate) }, - { "C", "1.5" }, - { "D", "1" }, - { "E", "NumberLong(2)" }, - { "G", "ObjectId('000000000000000000000000')" }, - { "H", "'x'" } - }; - if (expectedGuidJson != null) - { - reps.Add("F", expectedGuidJson); - } - var htRep = GetDocumentRepresentationInKeyOrder(d, reps); - var sdRep = GetDocumentRepresentationInKeyOrder(sd, reps); - var slRep = GetDocumentRepresentationInKeyOrder(sl, reps); - var expected = "{ 'D' : #D, 'ID' : #D, 'IROD' : #D, 'ROD' : #D, 'SD' : #SD, 'SL' : #SL }" - .Replace("#D", htRep) - .Replace("#SD", sdRep) - .Replace("#SL", slRep) - .Replace("'", "\""); - Assert.Equal(expected, json); + // Arrange + var subject = new DictionaryInterfaceImplementerSerializer>(DictionaryRepresentation.Document); - var bson = obj.ToBson(writerSettings: new BsonBinaryWriterSettings()); - var rehydrated = BsonSerializer.Deserialize(new BsonBinaryReader(new MemoryStream(bson), new BsonBinaryReaderSettings())); - Assert.IsType>(rehydrated.D); - Assert.IsType>(rehydrated.ID); - Assert.IsType>(rehydrated.IROD); - Assert.IsType>(rehydrated.ROD); - Assert.IsType>(rehydrated.SD); - Assert.IsType>(rehydrated.SL); - Assert.True(bson.SequenceEqual(rehydrated.ToBson(writerSettings: new BsonBinaryWriterSettings()))); + // Act + var result = subject.WithDictionaryRepresentation(DictionaryRepresentation.ArrayOfDocuments); + + // Assert + result.Should().NotBeSameAs(subject); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.ArrayOfDocuments); + result.KeySerializer.Should().BeSameAs(subject.KeySerializer); + result.ValueSerializer.Should().BeSameAs(subject.ValueSerializer); } [Fact] - public void TestMixedPrimitiveTypesWithIntKeys() + public void WithDictionaryRepresentation_with_same_representation_should_return_same_instance() { - var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); - var guid = Guid.Empty; - var objectId = ObjectId.Empty; - var d = new Dictionary - { - { 1, true }, - { 2, dateTime }, - { 3, 1.5 }, - { 4, 1 }, - { 5, 2L }, - { 6, guid }, - { 7, objectId }, - { 8, "x" } - }; - var rod = new ReadOnlyDictionary(d); - var sd = CreateSortedDictionary(d); - var sl = CreateSortedList(d); - var obj = new T { D = d, ID = d, IROD = rod, ROD = rod, SD = sd, SL = sl }; - Assert.Throws(() => obj.ToBson()); + // Arrange + var subject = new DictionaryInterfaceImplementerSerializer>(DictionaryRepresentation.Document); + + // Act + var result = subject.WithDictionaryRepresentation(DictionaryRepresentation.Document); + + // Assert + result.Should().BeSameAs(subject); } [Fact] - public void TestMixedPrimitiveTypesWithMixedKeys() + public void WithDictionaryRepresentation_with_serializers_and_different_representation_should_return_new_instance() { - // note: no SortedDictionary or SortedList in this test because you can't sort a set of keys that have mixed types - var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc); - var guid = Guid.Empty; - var objectId = ObjectId.Empty; - var d = new Dictionary - { - { "A", true }, - { "B", dateTime }, - { "C", 1.5 }, - { "D", 1 }, - { 4, 2L }, - { 5.0, guid }, - { true, objectId }, - { false, "x" } - }; - var obj = new T { D = d, ID = d, SD = null, SL = null }; - Assert.Throws(() => obj.ToBson()); + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + + // Act + var result = subject.WithDictionaryRepresentation(DictionaryRepresentation.ArrayOfDocuments, keySerializer, valueSerializer); + + // Assert + result.Should().NotBeSameAs(subject); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.ArrayOfDocuments); + result.KeySerializer.Should().BeSameAs(keySerializer); + result.ValueSerializer.Should().BeSameAs(valueSerializer); } [Fact] - public void TestImmutablePrivateConstructorDictionaryImplementation() + public void WithDictionaryRepresentation_with_serializers_and_same_values_should_return_same_instance() { - var d = new Dictionary { { "A", new C { P = "x" } } }; - var id = RO.ConstructorReplacement(d); - var irod = new ReadOnlyDictionary(d); - var rod = new ReadOnlyDictionary(d); - var sd = CreateSortedDictionary(d); - var sl = CreateSortedList(d); - var obj = new T { D = d, ID = id, IROD = irod, ROD = rod, SD = sd, SL = sl }; - var json = obj.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var rep = "{ 'A' : { '_t' : 'DictionaryGenericSerializers.C', 'P' : 'x' } }"; - var expected = "{ 'D' : #R, 'ID' : #R, 'IROD' : #R, 'ROD' : #R, 'SD' : #R, 'SL' : #R }".Replace("#R", rep).Replace("'", "\""); - Assert.Equal(expected, json); + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); - var bson = obj.ToBson(); - var rehydrated = BsonSerializer.Deserialize(bson); - Assert.IsType>(rehydrated.D); - Assert.IsType>(rehydrated.ID); - Assert.IsType>(rehydrated.IROD); - Assert.IsType>(rehydrated.ROD); - Assert.IsType>(rehydrated.SD); - Assert.IsType>(rehydrated.SL); - Assert.True(bson.SequenceEqual(rehydrated.ToBson())); + // Act + var result = subject.WithDictionaryRepresentation(DictionaryRepresentation.Document, keySerializer, valueSerializer); + + // Assert + result.Should().BeSameAs(subject); + } + + [Fact] + public void WithKeySerializer_with_different_serializer_should_return_new_instance() + { + // Arrange + var keySerializer1 = new StringSerializer(); + var keySerializer2 = new StringSerializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer1, new Int32Serializer()); + + // Act + var result = subject.WithKeySerializer(keySerializer2); + + // Assert + result.Should().NotBeSameAs(subject); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + result.KeySerializer.Should().BeSameAs(keySerializer2); + result.ValueSerializer.Should().BeSameAs(subject.ValueSerializer); + } + + [Fact] + public void WithKeySerializer_with_same_serializer_should_return_same_instance() + { + // Arrange + var keySerializer = new StringSerializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, keySerializer, new Int32Serializer()); + + // Act + var result = subject.WithKeySerializer(keySerializer); + + // Assert + result.Should().BeSameAs(subject); + } + + [Fact] + public void WithValueSerializer_with_different_serializer_should_return_new_instance() + { + // Arrange + var valueSerializer1 = new Int32Serializer(); + var valueSerializer2 = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, new StringSerializer(), valueSerializer1); + + // Act + var result = subject.WithValueSerializer(valueSerializer2); + + // Assert + result.Should().NotBeSameAs(subject); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + result.KeySerializer.Should().BeSameAs(subject.KeySerializer); + result.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void WithValueSerializer_with_same_serializer_should_return_same_instance() + { + // Arrange + var valueSerializer = new Int32Serializer(); + var subject = new DictionaryInterfaceImplementerSerializer>( + DictionaryRepresentation.Document, new StringSerializer(), valueSerializer); + + // Act + var result = subject.WithValueSerializer(valueSerializer); + + // Assert + result.Should().BeSameAs(subject); } private SortedDictionary CreateSortedDictionary(Dictionary d) @@ -523,32 +811,40 @@ private SortedList CreateSortedList(Dictionary d return sl; } - private string GetArrayRepresentationInKeyOrder( + private string GetDocumentRepresentationInKeyOrder( IDictionary dictionary, IDictionary representations) { var sb = new StringBuilder(); foreach (var key in dictionary.Keys) { - sb.Append((sb.Length == 0) ? "[" : ", "); - sb.Append(representations[key]); + sb.Append((sb.Length == 0) ? "{ " : ", "); + sb.AppendFormat("'{0}' : {1}", key, representations[key]); } - sb.Append("]"); + sb.Append(" }"); return sb.ToString(); } - private string GetDocumentRepresentationInKeyOrder( - IDictionary dictionary, - IDictionary representations) + public class RO : ReadOnlyDictionary { - var sb = new StringBuilder(); - foreach (var key in dictionary.Keys) + private RO(IDictionary dictionary) : base(dictionary) { - sb.Append((sb.Length == 0) ? "{ " : ", "); - sb.AppendFormat("'{0}' : {1}", key, representations[key]); } - sb.Append(" }"); - return sb.ToString(); + + public static RO ConstructorReplacement(IDictionary dictionary) + { + return new RO(dictionary); + } + } + + public class T + { + public Dictionary D { get; set; } + public IDictionary ID { get; set; } + public IReadOnlyDictionary IROD { get; set; } + public ReadOnlyDictionary ROD { get; set; } + public SortedDictionary SD { get; set; } + public SortedList SL { get; set; } } } @@ -561,36 +857,37 @@ private enum E B } - private class C + [Fact] + public void TestSerialize1() { - [BsonRepresentation(BsonType.String)] - public Dictionary Dictionary; - } + C c = new() { Dictionary = new Dictionary { { "a", E.A } } }; + var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); + var expected = ("{ 'Dictionary' : { \"a\" : \"A\" } }").Replace("'", "\""); + Assert.Equal(expected, json); - // required for deterministic tests - private class D - { - [BsonRepresentation(BsonType.String)] - public SortedList Dictionary; + var bson = c.ToBson(); + var rehydrated = BsonSerializer.Deserialize(bson); + Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } [Fact] - public void TestSerializeNull() + public void TestSerialize2() { - C c = new C { Dictionary = null }; - var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : null }").Replace("'", "\""); + D d = new() { Dictionary = new SortedList { { "a", E.A }, { "b", E.B } } }; + var json = d.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); + var expected = ("{ 'Dictionary' : { \"a\" : \"A\", \"b\" : \"B\" } }").Replace("'", "\""); Assert.Equal(expected, json); - var bson = c.ToBson(); - var rehydrated = BsonSerializer.Deserialize(bson); + var bson = d.ToBson(); + var rehydrated = BsonSerializer.Deserialize(bson); Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } [Fact] public void TestSerializeEmpty() { - C c = new C { Dictionary = new Dictionary() }; + Dictionary value = []; + C c = new() { Dictionary = value }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); var expected = ("{ 'Dictionary' : { } }").Replace("'", "\""); Assert.Equal(expected, json); @@ -601,11 +898,11 @@ public void TestSerializeEmpty() } [Fact] - public void TestSerialize1() + public void TestSerializeNull() { - C c = new C { Dictionary = new Dictionary { { "a", E.A } } }; + C c = new() { Dictionary = null }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : { \"a\" : \"A\" } }").Replace("'", "\""); + var expected = ("{ 'Dictionary' : null }").Replace("'", "\""); Assert.Equal(expected, json); var bson = c.ToBson(); @@ -613,37 +910,32 @@ public void TestSerialize1() Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } - [Fact] - public void TestSerialize2() + private class C { - D d = new D { Dictionary = new SortedList { { "a", E.A }, { "b", E.B } } }; - var json = d.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : { \"a\" : \"A\", \"b\" : \"B\" } }").Replace("'", "\""); - Assert.Equal(expected, json); + [BsonRepresentation(BsonType.String)] + public Dictionary Dictionary; + } - var bson = d.ToBson(); - var rehydrated = BsonSerializer.Deserialize(bson); - Assert.True(bson.SequenceEqual(rehydrated.ToBson())); + // required for deterministic tests + private class D + { + [BsonRepresentation(BsonType.String)] + public SortedList Dictionary; } } public class StringToObjectIdDictionaryTests { - private class C - { - [BsonRepresentation(BsonType.ObjectId)] - public Dictionary Dictionary; - } + private static readonly string id1 = "123456789012345678901234"; - private static string id1 = "123456789012345678901234"; - private static string id2 = "432109876543210987654321"; + private static readonly string id2 = "432109876543210987654321"; [Fact] - public void TestSerializeNull() + public void TestSerialize1() { - C c = new C { Dictionary = null }; + C c = new() { Dictionary = new Dictionary { { "a", id1 } } }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : null }").Replace("'", "\""); + var expected = ("{ 'Dictionary' : { \"a\" : ObjectId(\"123456789012345678901234\") } }").Replace("'", "\""); Assert.Equal(expected, json); var bson = c.ToBson(); @@ -652,12 +944,16 @@ public void TestSerializeNull() } [Fact] - public void TestSerializeEmpty() + public void TestSerialize2() { - C c = new C { Dictionary = new Dictionary() }; + C c = new() { Dictionary = new Dictionary { { "a", id1 }, { "b", id2 } } }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : { } }").Replace("'", "\""); - Assert.Equal(expected, json); + var expected1 = ("{ 'Dictionary' : { \"a\" : ObjectId(\"123456789012345678901234\"), \"b\" : ObjectId(\"432109876543210987654321\") } }").Replace("'", "\""); + var expected2 = ("{ 'Dictionary' : { \"b\" : ObjectId(\"432109876543210987654321\"), \"a\" : ObjectId(\"123456789012345678901234\") } }").Replace("'", "\""); + if (json != expected1 && json != expected2) + { + Assert.Equal(expected1, json); + } var bson = c.ToBson(); var rehydrated = BsonSerializer.Deserialize(bson); @@ -665,11 +961,11 @@ public void TestSerializeEmpty() } [Fact] - public void TestSerialize1() + public void TestSerializeEmpty() { - C c = new C { Dictionary = new Dictionary { { "a", id1 } } }; + C c = new() { Dictionary = [] }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected = ("{ 'Dictionary' : { \"a\" : ObjectId(\"123456789012345678901234\") } }").Replace("'", "\""); + var expected = ("{ 'Dictionary' : { } }").Replace("'", "\""); Assert.Equal(expected, json); var bson = c.ToBson(); @@ -678,20 +974,22 @@ public void TestSerialize1() } [Fact] - public void TestSerialize2() + public void TestSerializeNull() { - C c = new C { Dictionary = new Dictionary { { "a", id1 }, { "b", id2 } } }; + C c = new() { Dictionary = null }; var json = c.ToJson(writerSettings: new JsonWriterSettings { OutputMode = JsonOutputMode.Shell }); - var expected1 = ("{ 'Dictionary' : { \"a\" : ObjectId(\"123456789012345678901234\"), \"b\" : ObjectId(\"432109876543210987654321\") } }").Replace("'", "\""); - var expected2 = ("{ 'Dictionary' : { \"b\" : ObjectId(\"432109876543210987654321\"), \"a\" : ObjectId(\"123456789012345678901234\") } }").Replace("'", "\""); - if (json != expected1 && json != expected2) - { - Assert.Equal(expected1, json); - } + var expected = ("{ 'Dictionary' : null }").Replace("'", "\""); + Assert.Equal(expected, json); var bson = c.ToBson(); var rehydrated = BsonSerializer.Deserialize(bson); Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } + + private class C + { + [BsonRepresentation(BsonType.ObjectId)] + public Dictionary Dictionary; + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/DowncastingSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/DowncastingSerializerTests.cs index b871f801835..a198cf9cdac 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/DowncastingSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/DowncastingSerializerTests.cs @@ -13,15 +13,129 @@ * limitations under the License. */ +using System; using FluentAssertions; +using MongoDB.Bson.IO; using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers { public class DowncastingSerializerTests { + [Fact] + public void BaseType_property_should_return_correct_type() + { + // Arrange + var derivedSerializer = new StringSerializer(); + var subject = new DowncastingSerializer(derivedSerializer); + + // Act + var result = subject.BaseType; + + // Assert + result.Should().Be(typeof(object)); + } + + [Fact] + public void Constructor_should_initialize_instance() + { + // Arrange + var mockDerivedSerializer = new Mock>(); + + // Act + var subject = new MongoDB.Bson.Serialization.Serializers.DowncastingSerializer(mockDerivedSerializer.Object); + + // Assert + subject.DerivedSerializer.Should().BeSameAs(mockDerivedSerializer.Object); + subject.BaseType.Should().Be(typeof(object)); + subject.DerivedType.Should().Be(typeof(string)); + } + + [Fact] + public void Constructor_should_throw_when_derivedSerializer_is_null() + { + // Act + Action act = () => new MongoDB.Bson.Serialization.Serializers.DowncastingSerializer(null); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("derivedSerializer"); + } + + [Fact] + public void Create_should_create_instance_with_correct_types() + { + // Arrange + var baseType = typeof(object); + var derivedType = typeof(string); + var serializer = new StringSerializer(); + + // Act + var result = MongoDB.Bson.Serialization.Serializers.DowncastingSerializer.Create( + baseType, derivedType, serializer); + + // Assert + result.Should().NotBeNull(); + result.Should().BeOfType(typeof(MongoDB.Bson.Serialization.Serializers.DowncastingSerializer)); + var downcastingSerializer = (MongoDB.Bson.Serialization.Serializers.IDowncastingSerializer)result; + downcastingSerializer.BaseType.Should().Be(baseType); + downcastingSerializer.DerivedType.Should().Be(derivedType); + downcastingSerializer.DerivedSerializer.Should().BeSameAs(serializer); + } + + [Fact] + public void DerivedSerializer_property_should_return_provided_serializer() + { + // Arrange + var derivedSerializer = new StringSerializer(); + var subject = new DowncastingSerializer(derivedSerializer); + + // Act + var result = subject.DerivedSerializer; + + // Assert + result.Should().BeSameAs(derivedSerializer); + } + + [Fact] + public void DerivedType_property_should_return_correct_type() + { + // Arrange + var derivedSerializer = new StringSerializer(); + var subject = new DowncastingSerializer(derivedSerializer); + + // Act + var result = subject.DerivedType; + + // Assert + result.Should().Be(typeof(string)); + } + + [Fact] + public void Deserialize_should_delegate_to_derived_serializer() + { + // Arrange + var mockSerializer = new Mock>(); + var expectedResult = "test"; + mockSerializer + .Setup(s => s.Deserialize(It.IsAny(), It.IsAny())) + .Returns(expectedResult); + + var subject = new DowncastingSerializer(mockSerializer.Object); + var context = BsonDeserializationContext.CreateRoot(new Mock().Object); + var args = new BsonDeserializationArgs(); + + // Act + var result = subject.Deserialize(context, args); + + // Assert + result.Should().Be(expectedResult); + mockSerializer.Verify(s => s.Deserialize(context, args), Times.Once); + } + [Fact] public void Equals_null_should_return_false() { @@ -84,5 +198,122 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + + [Fact] + public void IDowncastingSerializer_DerivedSerializer_should_return_same_serializer() + { + // Arrange + var derivedSerializer = new StringSerializer(); + var subject = new DowncastingSerializer(derivedSerializer); + var downcastingSerializer = (IDowncastingSerializer)subject; + + // Act + var result = downcastingSerializer.DerivedSerializer; + + // Assert + result.Should().BeSameAs(derivedSerializer); + } + [Fact] + public void Serialize_should_delegate_to_derived_serializer_with_downcast_value() + { + // Arrange + var mockSerializer = new Mock>(); + var subject = new DowncastingSerializer(mockSerializer.Object); + var context = BsonSerializationContext.CreateRoot(new Mock().Object); + var args = new BsonSerializationArgs(); + var value = "test"; + + // Act + subject.Serialize(context, args, value); + + // Assert + mockSerializer.Verify(s => s.Serialize(context, It.IsAny(), value), Times.Once); + } + + [Fact] + public void TryGetItemSerializationInfo_should_delegate_to_derived_serializer_when_it_implements_IBsonArraySerializer() + { + // Arrange + var mockArraySerializer = new Mock>(); + mockArraySerializer.As() + .Setup(s => s.TryGetItemSerializationInfo(out It.Ref.IsAny)) + .Returns((out BsonSerializationInfo info) => + { + info = new BsonSerializationInfo("item", new StringSerializer(), typeof(string)); + return true; + }); + + var subject = new DowncastingSerializer(mockArraySerializer.Object); + + // Act + var result = subject.TryGetItemSerializationInfo(out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().NotBeNull(); + serializationInfo.ElementName.Should().Be("item"); + serializationInfo.NominalType.Should().Be(typeof(string)); + mockArraySerializer.As() + .Verify(s => s.TryGetItemSerializationInfo(out It.Ref.IsAny), Times.Once); + } + + [Fact] + public void TryGetItemSerializationInfo_should_throw_when_derived_serializer_does_not_implement_IBsonArraySerializer() + { + // Arrange + var mockSerializer = new Mock>(); + var subject = new DowncastingSerializer(mockSerializer.Object); + + // Act + Action act = () => subject.TryGetItemSerializationInfo(out _); + + // Assert + act.ShouldThrow() + .WithMessage($"The class {mockSerializer.Object.GetType().FullName} does not implement IBsonArraySerializer."); + } + + [Fact] + public void TryGetMemberSerializationInfo_should_delegate_to_derived_serializer_when_it_implements_IBsonDocumentSerializer() + { + // Arrange + var memberName = "testMember"; + var mockDocumentSerializer = new Mock>(); + mockDocumentSerializer.As() + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Returns((string name, out BsonSerializationInfo info) => + { + info = new BsonSerializationInfo(name, new StringSerializer(), typeof(string)); + return true; + }); + + var subject = new DowncastingSerializer(mockDocumentSerializer.Object); + + // Act + var result = subject.TryGetMemberSerializationInfo(memberName, out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().NotBeNull(); + serializationInfo.ElementName.Should().Be(memberName); + serializationInfo.NominalType.Should().Be(typeof(string)); + mockDocumentSerializer.As() + .Verify(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny), Times.Once); + } + + [Fact] + public void TryGetMemberSerializationInfo_should_throw_when_derived_serializer_does_not_implement_IBsonDocumentSerializer() + { + // Arrange + var mockSerializer = new Mock>(); + var subject = new DowncastingSerializer(mockSerializer.Object); + var memberName = "testMember"; + + // Act + Action act = () => subject.TryGetMemberSerializationInfo(memberName, out _); + + // Assert + act.ShouldThrow() + .WithMessage($"The class {mockSerializer.Object.GetType().FullName} does not implement IBsonDocumentSerializer."); + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/EnumerableInterfaceImplementerSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/EnumerableInterfaceImplementerSerializerTests.cs index ba33a1beb88..8982f264a83 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/EnumerableInterfaceImplementerSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/EnumerableInterfaceImplementerSerializerTests.cs @@ -21,6 +21,7 @@ using MongoDB.Bson.IO; using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers @@ -36,6 +37,80 @@ static EnumerableInterfaceImplementerSerializerTests() __itemSerializer2 = new Int32Serializer(BsonType.String); } + [Fact] + public void Constructor_should_throw_when_serializer_is_null() + { + // Act + Action act = () => new EnumerableInterfaceImplementerSerializer((IBsonSerializer)null); + + // Assert + act.ShouldThrow().And.ParamName.Should().Be("itemSerializer"); + } + + [Fact] + public void Constructor_should_throw_when_serializer_registry_is_null() + { + // Act + Action act = () => new EnumerableInterfaceImplementerSerializer((IBsonSerializerRegistry)null); + + // Assert + act.ShouldThrow().And.ParamName.Should().Be("serializerRegistry"); + } + + [Fact] + public void Constructor_with_item_serializer_should_initialize_instance_with_specified_serializer() + { + // Arrange + var itemSerializer = new StringSerializer(); + + // Act + var serializer = new EnumerableInterfaceImplementerSerializer(itemSerializer); + + // Assert + serializer.Should().NotBeNull(); + GetItemSerializer(serializer).Should().BeSameAs(itemSerializer); + } + + [Fact] + public void Constructor_with_no_arguments_should_initialize_instance() + { + // Arrange & Act + var serializer = new EnumerableInterfaceImplementerSerializer(); + + // Assert + serializer.Should().NotBeNull(); + GetItemSerializer(serializer).Should().NotBeNull(); + } + + [Fact] + public void Constructor_with_serializer_registry_should_initialize_instance() + { + // Arrange + var itemSerializer = new ObjectSerializer(); + var mockRegistry = new Mock(); + mockRegistry.Setup(r => r.GetSerializer(typeof(object))).Returns(itemSerializer); + + // Act + var serializer = new EnumerableInterfaceImplementerSerializer(mockRegistry.Object); + + // Assert + serializer.ItemSerializer.Should().Be(itemSerializer); + } + + [Fact] + public void CreateAccumulator_should_return_new_instance_of_TValue() + { + // Arrange + var serializer = new EnumerableInterfaceImplementerSerializer(); + + // Act + var result = InvokeCreateAccumulator(serializer); + + // Assert + result.Should().NotBeNull(); + result.Should().BeOfType(); + } + [Fact] public void Equals_null_should_return_false() { @@ -98,62 +173,108 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } - } - public class EnumerableInterfaceImplementerSerializerGenericTests - { - private static readonly IBsonSerializer __itemSerializer1; - private static readonly IBsonSerializer __itemSerializer2; + [Fact] + public void IChildSerializerConfigurable_ChildSerializer_should_return_ItemSerializer() + { + // Arrange + var itemSerializer = new StringSerializer(); + var serializer = new EnumerableInterfaceImplementerSerializer(itemSerializer); + var childSerializerConfigurable = (IChildSerializerConfigurable)serializer; - static EnumerableInterfaceImplementerSerializerGenericTests() + // Act + var result = childSerializerConfigurable.ChildSerializer; + + // Assert + result.Should().BeSameAs(itemSerializer); + } + + [Fact] + public void IChildSerializerConfigurable_WithChildSerializer_should_return_serializer_with_specified_child_serializer() { - __itemSerializer1 = new Int32Serializer(BsonType.Int32); - __itemSerializer2 = new Int32Serializer(BsonType.String); + // Arrange + var originalItemSerializer = new StringSerializer(); + var originalSerializer = new EnumerableInterfaceImplementerSerializer(originalItemSerializer); + var newItemSerializer = new Int32Serializer(); + var childSerializerConfigurable = (IChildSerializerConfigurable)originalSerializer; + + // Act + var result = childSerializerConfigurable.WithChildSerializer(newItemSerializer); + + // Assert + result.Should().NotBeNull(); + result.Should().NotBeSameAs(originalSerializer); + result.Should().BeOfType>(); + var resultSerializer = (EnumerableInterfaceImplementerSerializer)result; + GetItemSerializer(resultSerializer).Should().BeSameAs(newItemSerializer); } - public class C : IEnumerable + [Fact] + public void WithItemSerializer_should_return_new_serializer_with_specified_item_serializer() { - public int Id; - public List Children; + // Arrange + var originalItemSerializer = new StringSerializer(); + var originalSerializer = new EnumerableInterfaceImplementerSerializer(originalItemSerializer); + var newItemSerializer = new Int32Serializer(); + + // Act + var result = originalSerializer.WithItemSerializer(newItemSerializer); + + // Assert + result.Should().NotBeNull(); + result.Should().NotBeSameAs(originalSerializer); + result.Should().BeOfType>(); + GetItemSerializer(result).Should().BeSameAs(newItemSerializer); + } - public IEnumerator GetEnumerator() - { - return Children.GetEnumerator(); - } + // Helper method to get the ItemSerializer property via reflection + private IBsonSerializer GetItemSerializer(EnumerableInterfaceImplementerSerializer serializer) + where TValue : IEnumerable, new() + { + var propertyInfo = typeof(EnumerableInterfaceImplementerSerializerBase<>) + .MakeGenericType(typeof(TValue)) + .GetProperty("ItemSerializer", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); - IEnumerator IEnumerable.GetEnumerator() - { - return GetEnumerator(); - } + return (IBsonSerializer)propertyInfo.GetValue(serializer); } - [Fact] - public void LookupSerializer_should_not_throw_StackOverflowException() + // Helper method to invoke protected CreateAccumulator method via reflection + private object InvokeCreateAccumulator(EnumerableInterfaceImplementerSerializer serializer) + where TValue : IEnumerable, new() { - var serializer = BsonSerializer.LookupSerializer(); + var methodInfo = typeof(EnumerableInterfaceImplementerSerializer) + .GetMethod("CreateAccumulator", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); - serializer.Should().BeOfType>(); - var itemSerializer = ((EnumerableInterfaceImplementerSerializer)serializer).ItemSerializer; - itemSerializer.Should().BeSameAs(serializer); + return methodInfo.Invoke(serializer, null); } - [Fact] - public void Serialize_should_return_expected_result() + // Test implementation of IEnumerable for testing + private class TestEnumerable : IEnumerable { - var subject = CreateSubject(); + private readonly List _items = new(); - using (var stringWriter = new StringWriter()) - using (var jsonWriter = new JsonWriter(stringWriter)) + public void Add(object item) { - var context = BsonSerializationContext.CreateRoot(jsonWriter); - var value = new C { Id = 1, Children = new List { new C { Id = 2, Children = new List() } } }; - - subject.Serialize(context, value); + _items.Add(item); + } - var json = stringWriter.ToString(); - json.Should().Be("[[]]"); + public IEnumerator GetEnumerator() + { + return _items.GetEnumerator(); } } + } + + public class EnumerableInterfaceImplementerSerializerGenericTests + { + private static readonly IBsonSerializer __itemSerializer1; + private static readonly IBsonSerializer __itemSerializer2; + + static EnumerableInterfaceImplementerSerializerGenericTests() + { + __itemSerializer1 = new Int32Serializer(BsonType.Int32); + __itemSerializer2 = new Int32Serializer(BsonType.String); + } [Fact] public void Equals_null_should_return_false() @@ -218,6 +339,34 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + [Fact] + public void LookupSerializer_should_not_throw_StackOverflowException() + { + var serializer = BsonSerializer.LookupSerializer(); + + serializer.Should().BeOfType>(); + var itemSerializer = ((EnumerableInterfaceImplementerSerializer)serializer).ItemSerializer; + itemSerializer.Should().BeSameAs(serializer); + } + + [Fact] + public void Serialize_should_return_expected_result() + { + var subject = CreateSubject(); + + using (var stringWriter = new StringWriter()) + using (var jsonWriter = new JsonWriter(stringWriter)) + { + var context = BsonSerializationContext.CreateRoot(jsonWriter); + var value = new C { Id = 1, Children = new List { new C { Id = 2, Children = new List() } } }; + + subject.Serialize(context, value); + + var json = stringWriter.ToString(); + json.Should().Be("[[]]"); + } + } + private IBsonSerializer CreateSubject() { // create subject without using the global serializer registry @@ -226,5 +375,21 @@ private IBsonSerializer CreateSubject() serializerRegistry.RegisterSerializer(typeof(C), subject); return subject; } + + public class C : IEnumerable + { + public List Children; + public int Id; + + public IEnumerator GetEnumerator() + { + return Children.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/IOrderedEnumerableSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/IOrderedEnumerableSerializerTests.cs index d98f11bb2de..25dea5988a4 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/IOrderedEnumerableSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/IOrderedEnumerableSerializerTests.cs @@ -14,7 +14,10 @@ */ using System; +using System.Collections.Generic; +using System.Linq; using FluentAssertions; +using MongoDB.Bson.IO; using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; using Xunit; @@ -23,6 +26,183 @@ namespace MongoDB.Bson.Tests.Serialization.Serializers { public class IOrderedEnumerableSerializerTests { + [Fact] + public void Constructor_should_initialize_instance() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + + // Act + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Assert + subject.Should().NotBeNull(); + } + + [Fact] + public void Constructor_should_throw_when_itemSerializer_is_null() + { + // Arrange + IBsonSerializer itemSerializer = null; + var thenByExceptionMessage = "ThenBy is not supported"; + + // Act + Action act = () => new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("itemSerializer"); + } + + [Fact] + public void Constructor_should_throw_when_thenByExceptionMessage_is_null() + { + // Arrange + var itemSerializer = new StringSerializer(); + string thenByExceptionMessage = null; + + // Act + Action act = () => new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("thenByExceptionMessage"); + } + + [Fact] + public void Create_should_create_serializer_with_correct_item_type() + { + // Arrange + var itemSerializer = new Int32Serializer(); + string exceptionMessage = "ThenBy is not supported"; + + // Act + var result = IOrderedEnumerableSerializer.Create(itemSerializer, exceptionMessage); + + // Assert + result.Should().NotBeNull(); + result.Should().BeOfType(typeof(IOrderedEnumerableSerializer)); + } + + [Fact] + public void Create_should_throw_when_itemSerializer_is_null() + { + // Arrange + IBsonSerializer itemSerializer = null; + string exceptionMessage = "ThenBy is not supported"; + + // Act + Action act = () => IOrderedEnumerableSerializer.Create(itemSerializer, exceptionMessage); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("itemSerializer"); + } + + [Fact] + public void Deserialize_should_create_ordered_enumerable_list_wrapper() + { + // Arrange + var itemSerializer = new Int32Serializer(); + var subject = new IOrderedEnumerableSerializer(itemSerializer, "ThenBy is not supported"); + + var document = new BsonDocument("x", new BsonArray(new[] { 1, 2, 3 })); + using var reader = new BsonDocumentReader(document); + var context = BsonDeserializationContext.CreateRoot(reader); + reader.ReadStartDocument(); + reader.ReadName("x"); + + // Act + var result = subject.Deserialize(context); + + // Assert + result.Should().NotBeNull(); + result.Should().BeAssignableTo>(); + result.Should().BeOfType>(); + result.Count().Should().Be(3); + result.Should().Equal([1, 2, 3]); + } + + [Fact] + public void Deserialize_should_return_ordered_enumerable() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + var document = new BsonDocument("items", new BsonArray(new[] { "a", "b", "c" })); + using var reader = new BsonDocumentReader(document); + var context = BsonDeserializationContext.CreateRoot(reader); + + reader.ReadStartDocument(); + reader.ReadName("items"); + + // Act + var result = subject.Deserialize(context, new BsonDeserializationArgs()); + + // Assert + result.Should().NotBeNull(); + result.Should().BeAssignableTo>(); + result.Should().ContainInOrder("a", "b", "c"); + + // Verify ThenBy throws with the expected message + Action act = () => result.ThenBy(x => x.Length); + act.ShouldThrow().WithMessage(thenByExceptionMessage); + + reader.ReadEndDocument(); + } + + [Fact] + public void Equals_different_item_serializer_should_return_false() + { + // Arrange + var itemSerializer1 = new StringSerializer(); + var itemSerializer2 = new StringSerializer(BsonType.ObjectId); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject1 = new IOrderedEnumerableSerializer(itemSerializer1, thenByExceptionMessage); + var subject2 = new IOrderedEnumerableSerializer(itemSerializer2, thenByExceptionMessage); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_different_then_by_exception_message_should_return_false() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage1 = "ThenBy is not supported 1"; + var thenByExceptionMessage2 = "ThenBy is not supported 2"; + var subject1 = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage1); + var subject2 = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage2); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_different_type_should_return_false() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Act + var result = subject.Equals(new object()); + + // Assert + result.Should().BeFalse(); + } + [Fact] public void Equals_null_should_return_false() { @@ -44,6 +224,35 @@ public void Equals_object_should_return_false() result.Should().Be(false); } + [Fact] + public void Equals_same_instance_should_return_true() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Act + var result = subject.Equals(subject); + + // Assert + result.Should().BeTrue(); + } + [Fact] + public void Equals_same_values_should_return_true() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject1 = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + var subject2 = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeTrue(); + } [Fact] public void Equals_self_should_return_true() { @@ -94,5 +303,96 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + + [Fact] + public void Serialize_should_write_array_of_items() + { + // Arrange + var itemSerializer = new Int32Serializer(); + var subject = new IOrderedEnumerableSerializer(itemSerializer, "ThenBy is not supported"); + var list = new OrderedEnumerableListWrapper([1, 2, 3], "ThenBy is not supported"); + + var document = new BsonDocument(); + using var writer = new BsonDocumentWriter(document); + var context = BsonSerializationContext.CreateRoot(writer); + writer.WriteStartDocument(); + writer.WriteName("x"); + + // Act + subject.Serialize(context, list); + writer.WriteEndDocument(); + + // Assert + document["x"].Should().Be(new BsonArray(new[] { 1, 2, 3 })); + } + + [Fact] + public void Serialize_should_write_array_with_items() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + var orderedEnumerable = new List { "a", "b", "c" } + .OrderBy(x => x); + + var document = new BsonDocument(); + using var writer = new BsonDocumentWriter(document); + var context = BsonSerializationContext.CreateRoot(writer); + + writer.WriteStartDocument(); + writer.WriteName("items"); + + // Act + subject.Serialize(context, new BsonSerializationArgs(), orderedEnumerable); + + // Assert + writer.WriteEndDocument(); + + document.Should().NotBeNull(); + document.ElementCount.Should().Be(1); + document["items"].Should().BeOfType(); + document["items"].AsBsonArray.Count.Should().Be(3); + document["items"].AsBsonArray[0].AsString.Should().Be("a"); + document["items"].AsBsonArray[1].AsString.Should().Be("b"); + document["items"].AsBsonArray[2].AsString.Should().Be("c"); + } + + [Fact] + public void TryGetItemSerializationInfo_should_return_correct_info() + { + // Arrange + var itemSerializer = new Int32Serializer(); + var subject = new IOrderedEnumerableSerializer(itemSerializer, "ThenBy is not supported"); + + // Act + var success = subject.TryGetItemSerializationInfo(out BsonSerializationInfo info); + + // Assert + success.Should().BeTrue(); + info.Should().NotBeNull(); + info.Serializer.Should().BeSameAs(itemSerializer); + info.NominalType.Should().Be(typeof(int)); + } + + [Fact] + public void TryGetItemSerializationInfo_should_return_true_and_serialization_info() + { + // Arrange + var itemSerializer = new StringSerializer(); + var thenByExceptionMessage = "ThenBy is not supported"; + var subject = new IOrderedEnumerableSerializer(itemSerializer, thenByExceptionMessage); + + // Act + var result = subject.TryGetItemSerializationInfo(out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().NotBeNull(); + serializationInfo.ElementName.Should().BeNull(); + serializationInfo.Serializer.Should().BeSameAs(itemSerializer); + serializationInfo.NominalType.Should().Be(typeof(string)); + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/ImpliedImplementationInterfaceSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/ImpliedImplementationInterfaceSerializerTests.cs index 6b9c20268c8..0ca6fe733bf 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/ImpliedImplementationInterfaceSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/ImpliedImplementationInterfaceSerializerTests.cs @@ -13,15 +13,186 @@ * limitations under the License. */ +using System; using System.Collections.Generic; using FluentAssertions; +using MongoDB.Bson.IO; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Options; using MongoDB.Bson.Serialization.Serializers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers { public class ImpliedImplementationInterfaceSerializerTests { + // Test interfaces and implementations + public interface ITestInterface { } + + public class TestImplementation : ITestInterface { } + + public class DerivedImplementation : TestImplementation { } + + [Fact] + public void Constructor_should_throw_when_implementation_serializer_is_null() + { + // Arrange + IBsonSerializer implementationSerializer = null; + + // Act + Action act = () => new ImpliedImplementationInterfaceSerializer(implementationSerializer); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("implementationSerializer"); + } + + [Fact] + public void Constructor_should_throw_when_TInterface_is_not_interface() + { + // Act + Action act = () => new ImpliedImplementationInterfaceSerializer(); + + // Assert + act.ShouldThrow() + .WithMessage($"{typeof(TestImplementation).FullName} is not an interface.*") + .And.ParamName.Should().Be(""); + } + + [Fact] + public void Constructor_with_implementation_serializer_should_initialize_instance() + { + // Arrange + var implementationSerializer = new Mock>().Object; + + // Act + var subject = new ImpliedImplementationInterfaceSerializer(implementationSerializer); + + // Assert + subject.Should().NotBeNull(); + subject.ImplementationSerializer.Should().BeSameAs(implementationSerializer); + } + [Fact] + public void Constructor_with_serializer_registry_should_initialize_instance() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var mockRegistry = new Mock(); + mockRegistry.Setup(r => r.GetSerializer()).Returns(implementationSerializer); + + // Act + var subject = new ImpliedImplementationInterfaceSerializer(mockRegistry.Object); + var actualSerializer = subject.ImplementationSerializer; + + // Assert + subject.Should().NotBeNull(); + actualSerializer.Should().Be(implementationSerializer); + + mockRegistry.Verify(r => r.GetSerializer(), Times.Once); + } + + [Fact] + public void Constructor_with_serializer_registry_should_throw_when_registry_is_null() + { + // Arrange + IBsonSerializerRegistry serializerRegistry = null; + + // Act + Action act = () => new ImpliedImplementationInterfaceSerializer(serializerRegistry); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("serializerRegistry"); + } + [Fact] + public void Deserialize_should_delegate_to_implementation_serializer() + { + // Arrange + var expected = new TestImplementation(); + var mockImplementationSerializer = new Mock>(); + mockImplementationSerializer.Setup(s => s.Deserialize(It.IsAny(), It.IsAny())) + .Returns(expected); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockImplementationSerializer.Object); + + var json = "{ }"; + var bsonDocument = BsonDocument.Parse("{ value: " + json + " }"); + using var reader = new BsonDocumentReader(bsonDocument); + reader.ReadStartDocument(); + reader.ReadName("value"); + var context = BsonDeserializationContext.CreateRoot(reader); + var args = new BsonDeserializationArgs(); + + // Act + var result = subject.Deserialize(context, args); + + // Assert + result.Should().BeSameAs(expected); + mockImplementationSerializer.Verify(s => s.Deserialize(context, args), Times.Once); + } + + [Fact] + public void Deserialize_should_deserialize_null_as_default_value() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer(implementationSerializer); + + var json = "null"; + var bsonDocument = BsonDocument.Parse("{ value: " + json + " }"); + using var reader = new BsonDocumentReader(bsonDocument); + reader.ReadStartDocument(); + reader.ReadName("value"); + var context = BsonDeserializationContext.CreateRoot(reader); + var args = new BsonDeserializationArgs(); + + // Act + var result = subject.Deserialize(context, args); + + // Assert + result.Should().BeNull(); + reader.ReadEndDocument(); + } + + [Fact] + public void DictionaryRepresentation_should_return_value_from_implementation_serializer() + { + // Arrange + var expected = DictionaryRepresentation.ArrayOfDocuments; + var mockDictionarySerializer = new Mock>(); + mockDictionarySerializer.As() + .Setup(s => s.DictionaryRepresentation) + .Returns(expected); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockDictionarySerializer.Object); + + // Act + var result = subject.DictionaryRepresentation; + + // Assert + result.Should().Be(expected); + mockDictionarySerializer.As().Verify(s => s.DictionaryRepresentation, Times.Once); + } + + [Fact] + public void DictionaryRepresentation_should_throw_when_implementation_serializer_is_not_IDictionarySerializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + Action act = () => { var _ = subject.DictionaryRepresentation; }; + + // Assert + act.ShouldThrow() + .WithMessage($"{BsonUtils.GetFriendlyTypeName(implementationSerializer.GetType())} does not have a DictionaryRepresentation.*"); + } + [Fact] public void Equals_null_should_return_false() { @@ -53,6 +224,71 @@ public void Equals_self_should_return_true() result.Should().Be(true); } + [Fact] + public void Equals_should_return_false_when_implementation_serializers_are_not_equal() + { + // Arrange + var implementationSerializer1 = new Mock>().Object; + var implementationSerializer2 = new Mock>().Object; + var subject1 = new ImpliedImplementationInterfaceSerializer( + implementationSerializer1); + var subject2 = new ImpliedImplementationInterfaceSerializer( + implementationSerializer2); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_should_return_false_when_other_is_null() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject.Equals(null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_should_return_true_when_implementation_serializers_are_equal() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject1 = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + var subject2 = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_should_return_true_when_same_instance() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject.Equals(subject); + + // Assert + result.Should().BeTrue(); + } + [Fact] public void Equals_with_equal_fields_should_return_true() { @@ -88,5 +324,328 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + + [Fact] + public void IChildSerializerConfigurable_ChildSerializer_should_return_implementation_serializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + var configurable = (IChildSerializerConfigurable)subject; + + // Act + var result = configurable.ChildSerializer; + + // Assert + result.Should().BeSameAs(implementationSerializer); + } + + [Fact] + public void IChildSerializerConfigurable_WithChildSerializer_should_return_new_instance_with_updated_serializer() + { + // Arrange + var implementationSerializer1 = new Mock>().Object; + var implementationSerializer2 = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer1); + var configurable = (IChildSerializerConfigurable)subject; + + // Act + var result = configurable.WithChildSerializer(implementationSerializer2); + + // Assert + result.Should().NotBeSameAs(subject); + result.Should().BeOfType>(); + var typedResult = (ImpliedImplementationInterfaceSerializer)result; + typedResult.ImplementationSerializer.Should().BeSameAs(implementationSerializer2); + } + + [Fact] + public void IImpliedImplementationInterfaceSerializer_ImplementationSerializer_should_return_implementation_serializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + var interfaceSerializer = (IImpliedImplementationInterfaceSerializer)subject; + + // Act + var result = interfaceSerializer.ImplementationSerializer; + + // Assert + result.Should().BeSameAs(implementationSerializer); + } + + [Fact] + public void KeySerializer_should_return_value_from_implementation_serializer() + { + // Arrange + var expected = new StringSerializer(); + var mockDictionarySerializer = new Mock>(); + mockDictionarySerializer.As() + .Setup(s => s.KeySerializer) + .Returns(expected); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockDictionarySerializer.Object); + + // Act + var result = subject.KeySerializer; + + // Assert + result.Should().BeSameAs(expected); + mockDictionarySerializer.As().Verify(s => s.KeySerializer, Times.Once); + } + + [Fact] + public void KeySerializer_should_throw_when_implementation_serializer_is_not_IDictionarySerializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + Action act = () => { var _ = subject.KeySerializer; }; + + // Assert + act.ShouldThrow() + .WithMessage($"{BsonUtils.GetFriendlyTypeName(implementationSerializer.GetType())} does not have a KeySerializer.*"); + } + + [Fact] + public void Serialize_should_delegate_to_implementation_serializer_when_value_type_matches_TImplementation() + { + // Arrange + var mockImplementationSerializer = new Mock>(); + var subject = new ImpliedImplementationInterfaceSerializer( + mockImplementationSerializer.Object); + + ITestInterface value = new TestImplementation(); + var bsonDocument = new BsonDocument(); + using var writer = new BsonDocumentWriter(bsonDocument); + writer.WriteStartDocument(); + writer.WriteName("value"); + var context = BsonSerializationContext.CreateRoot(writer); + var args = new BsonSerializationArgs(); + + // Act + subject.Serialize(context, args, value); + //writer.WriteEndDocument(); + + // Assert + mockImplementationSerializer.Verify(s => s.Serialize(context, args, (TestImplementation)value), Times.Once); + } + + [Fact] + public void Serialize_should_use_appropriate_serializer_when_value_type_is_not_TImplementation() + { + // Arrange + // We'll need to set up BsonSerializer.LookupSerializer, which is a static method + // This test demonstrates the behavior by checking the document structure + + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + ITestInterface value = new DerivedImplementation(); + var bsonDocument = new BsonDocument(); + using var writer = new BsonDocumentWriter(bsonDocument); + writer.WriteStartDocument(); + writer.WriteName("value"); + var context = BsonSerializationContext.CreateRoot(writer); + var args = new BsonSerializationArgs(); + + // The test will pass if no exception is thrown and the document is not null + + // Act + subject.Serialize(context, args, value); + writer.WriteEndDocument(); + + // Assert + bsonDocument["value"].Should().NotBeNull(); + } + + [Fact] + public void Serialize_should_write_null_when_value_is_null() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + ITestInterface value = null; + var bsonDocument = new BsonDocument(); + using var writer = new BsonDocumentWriter(bsonDocument); + writer.WriteStartDocument(); + writer.WriteName("value"); + var context = BsonSerializationContext.CreateRoot(writer); + var args = new BsonSerializationArgs(); + + // Act + subject.Serialize(context, args, value); + writer.WriteEndDocument(); + + // Assert + bsonDocument["value"].Should().Be(BsonNull.Value); + } + + [Fact] + public void TryGetItemSerializationInfo_should_delegate_to_implementation_serializer() + { + // Arrange + var expectedInfo = new BsonSerializationInfo("item", new Int32Serializer(), typeof(int)); + var mockArraySerializer = new Mock>(); + mockArraySerializer.As() + .Setup(s => s.TryGetItemSerializationInfo(out It.Ref.IsAny)) + .Returns((out BsonSerializationInfo info) => + { + info = expectedInfo; + return true; + }); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockArraySerializer.Object); + + // Act + var result = subject.TryGetItemSerializationInfo(out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().BeSameAs(expectedInfo); + mockArraySerializer.As().Verify( + s => s.TryGetItemSerializationInfo(out It.Ref.IsAny), + Times.Once); + } + + [Fact] + public void TryGetItemSerializationInfo_should_return_false_when_implementation_serializer_is_not_IArraySerializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject.TryGetItemSerializationInfo(out var serializationInfo); + + // Assert + result.Should().BeFalse(); + serializationInfo.Should().BeNull(); + } + + [Fact] + public void TryGetMemberSerializationInfo_should_delegate_to_implementation_serializer() + { + // Arrange + var memberName = "memberName"; + var expectedInfo = new BsonSerializationInfo(memberName, new Int32Serializer(), typeof(int)); + var mockDocumentSerializer = new Mock>(); + mockDocumentSerializer.As() + .Setup(s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny)) + .Returns((string name, out BsonSerializationInfo info) => + { + info = expectedInfo; + return true; + }); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockDocumentSerializer.Object); + + // Act + var result = subject.TryGetMemberSerializationInfo(memberName, out var serializationInfo); + + // Assert + result.Should().BeTrue(); + serializationInfo.Should().BeSameAs(expectedInfo); + mockDocumentSerializer.As().Verify( + s => s.TryGetMemberSerializationInfo(memberName, out It.Ref.IsAny), + Times.Once); + } + + [Fact] + public void TryGetMemberSerializationInfo_should_return_false_when_implementation_serializer_is_not_IDocumentSerializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject.TryGetMemberSerializationInfo("memberName", out var serializationInfo); + + // Assert + result.Should().BeFalse(); + serializationInfo.Should().BeNull(); + } + + [Fact] + public void ValueSerializer_should_return_value_from_implementation_serializer() + { + // Arrange + var expected = new Int32Serializer(); + var mockDictionarySerializer = new Mock>(); + mockDictionarySerializer.As() + .Setup(s => s.ValueSerializer) + .Returns(expected); + + var subject = new ImpliedImplementationInterfaceSerializer( + mockDictionarySerializer.Object); + + // Act + var result = subject.ValueSerializer; + + // Assert + result.Should().BeSameAs(expected); + mockDictionarySerializer.As().Verify(s => s.ValueSerializer, Times.Once); + } + + [Fact] + public void ValueSerializer_should_throw_when_implementation_serializer_is_not_IDictionarySerializer() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + Action act = () => { var _ = subject.ValueSerializer; }; + + // Assert + act.ShouldThrow() + .WithMessage($"{BsonUtils.GetFriendlyTypeName(implementationSerializer.GetType())} does not have a ValueSerializer.*"); + } + [Fact] + public void WithImplementationSerializer_should_return_new_instance_when_serializer_is_different() + { + // Arrange + var implementationSerializer1 = new Mock>().Object; + var implementationSerializer2 = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer1); + + // Act + var result = subject.WithImplementationSerializer(implementationSerializer2); + + // Assert + result.Should().NotBeSameAs(subject); + result.ImplementationSerializer.Should().BeSameAs(implementationSerializer2); + } + + [Fact] + public void WithImplementationSerializer_should_return_same_instance_when_serializer_is_same() + { + // Arrange + var implementationSerializer = new Mock>().Object; + var subject = new ImpliedImplementationInterfaceSerializer( + implementationSerializer); + + // Act + var result = subject.WithImplementationSerializer(implementationSerializer); + + // Assert + result.Should().BeSameAs(subject); + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/NullableSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/NullableSerializerTests.cs index 5fa3a3d60a9..5d5f1f6cab5 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/NullableSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/NullableSerializerTests.cs @@ -13,14 +13,64 @@ * limitations under the License. */ +using System; using FluentAssertions; +using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers { public class NullableSerializerTests { + [Theory] + [InlineData(42)] + [InlineData(null)] + public void Constructor_with_serializer_should_create_instance_with_assigned_value_serializer(int? testValue) + { + // Arrange + var mockSerializer = new Mock>(); + mockSerializer.SetupGet(s => s.ValueType).Returns(typeof(int)); + + // Act + var subject = new NullableSerializer(mockSerializer.Object); + + // Assert + subject.Should().NotBeNull(); + subject.ValueSerializer.Should().BeSameAs(mockSerializer.Object); + } + + [Fact] + public void Create_should_create_nullable_serializer_with_correct_value_type() + { + // Arrange + var valueSerializer = new Int32Serializer(); + + // Act + var result = NullableSerializer.Create(valueSerializer); + + // Assert + result.Should().NotBeNull(); + result.Should().BeOfType(typeof(NullableSerializer)); + result.ValueType.Should().Be(typeof(int?)); + + var nullableSerializer = (INullableSerializer)result; + nullableSerializer.ValueSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void Create_should_throw_when_valueSerializer_is_null() + { + // Arrange + IBsonSerializer valueSerializer = null; + + // Act + Action act = () => NullableSerializer.Create(valueSerializer); + + // Assert + act.ShouldThrow(); + } [Fact] public void Equals_null_should_return_false() { diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/OrderedEnumerableListWrapperTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/OrderedEnumerableListWrapperTests.cs new file mode 100644 index 00000000000..a13a23495e7 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/OrderedEnumerableListWrapperTests.cs @@ -0,0 +1,116 @@ +/* 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; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using FluentAssertions; +using MongoDB.Bson.Serialization.Serializers; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.Serializers +{ + public class OrderedEnumerableListWrapperTests + { + [Fact] + public void Constructor_should_initialize_list_and_exception_message() + { + // Arrange + var list = new List { 1, 2, 3 }; + var exceptionMessage = "ThenBy is not supported"; + + // Act + var subject = new OrderedEnumerableListWrapper(list, exceptionMessage); + + // Assert + subject.Should().NotBeNull(); + subject.Should().BeAssignableTo>(); + } + + [Fact] + public void GetEnumerator_should_return_list_enumerator() + { + // Arrange + var list = new List { 1, 2, 3 }; + var subject = new OrderedEnumerableListWrapper(list, "ThenBy is not supported"); + + // Act + var enumerator = subject.GetEnumerator(); + + // Assert + enumerator.Should().NotBeNull(); + var enumerated = new List(); + while (enumerator.MoveNext()) + { + enumerated.Add(enumerator.Current); + } + enumerated.Should().Equal(list); + } + + [Fact] + public void GetEnumerator_non_generic_should_return_enumerable_enumerator() + { + // Arrange + var list = new List { 1, 2, 3 }; + var subject = new OrderedEnumerableListWrapper(list, "ThenBy is not supported"); + + // Act + var enumerator = ((IEnumerable)subject).GetEnumerator(); + + // Assert + enumerator.Should().NotBeNull(); + var enumerated = new List(); + while (enumerator.MoveNext()) + { + enumerated.Add((int)enumerator.Current); + } + enumerated.Should().Equal(list); + } + + [Fact] + public void CreateOrderedEnumerable_should_throw_with_configured_message() + { + // Arrange + var list = new List { 1, 2, 3 }; + var exceptionMessage = "Custom exception message"; + var subject = new OrderedEnumerableListWrapper(list, exceptionMessage); + + // Act + Action act = () => subject.CreateOrderedEnumerable(x => x, Comparer.Default, false); + + // Assert + act.ShouldThrow().WithMessage(exceptionMessage); + } + + [Fact] + public void Should_be_enumerable_using_foreach() + { + // Arrange + var list = new List { 1, 2, 3 }; + var subject = new OrderedEnumerableListWrapper(list, "ThenBy is not supported"); + var enumerated = new List(); + + // Act + foreach (var item in subject) + { + enumerated.Add(item); + } + + // Assert + enumerated.Should().Equal(list); + } + } +} diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/ReadOnlyDictionaryInterfaceImplementerSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/ReadOnlyDictionaryInterfaceImplementerSerializerTests.cs index bb10a014cfa..b4e12ee480a 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/ReadOnlyDictionaryInterfaceImplementerSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/ReadOnlyDictionaryInterfaceImplementerSerializerTests.cs @@ -15,7 +15,9 @@ using System; using System.Collections.Generic; +using System.Collections.ObjectModel; using FluentAssertions; +using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Options; using MongoDB.Bson.Serialization.Serializers; using Xunit; @@ -24,6 +26,49 @@ namespace MongoDB.Bson.Tests.Serialization.Serializers { public class ReadOnlyDictionaryInterfaceImplementerSerializerTests { + [Fact] + public void Constructor_should_initialize_instance() + { + // Act + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(); + + // Assert + serializer.Should().NotBeNull(); + serializer.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + } + + [Fact] + public void Constructor_with_dictionary_representation_and_serializers_should_initialize_instance() + { + // Arrange + var dictionaryRepresentation = DictionaryRepresentation.ArrayOfDocuments; + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + + // Act + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + dictionaryRepresentation, keySerializer, valueSerializer); + + // Assert + serializer.Should().NotBeNull(); + serializer.DictionaryRepresentation.Should().Be(dictionaryRepresentation); + serializer.KeySerializer.Should().BeSameAs(keySerializer); + serializer.ValueSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void Constructor_with_dictionary_representation_should_initialize_instance() + { + // Arrange + var dictionaryRepresentation = DictionaryRepresentation.ArrayOfDocuments; + + // Act + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(dictionaryRepresentation); + + // Assert + serializer.Should().NotBeNull(); + serializer.DictionaryRepresentation.Should().Be(dictionaryRepresentation); + } [Fact] public void Equals_null_should_return_false() { @@ -101,5 +146,315 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + + [Fact] + public void IChildSerializerConfigurable_ChildSerializer_should_return_ValueSerializer() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + + // Act + var childSerializer = ((IChildSerializerConfigurable)serializer).ChildSerializer; + + // Assert + childSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void IChildSerializerConfigurable_WithChildSerializer_should_return_new_instance() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var valueSerializer2 = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, valueSerializer1); + var configurableSerializer = (IChildSerializerConfigurable)serializer; + + // Act + var result = configurableSerializer.WithChildSerializer(valueSerializer2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.Should().BeOfType, string, int>>(); + var typedResult = (ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>)result; + typedResult.KeySerializer.Should().BeSameAs(keySerializer); + typedResult.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void IDictionaryRepresentationConfigurable_WithDictionaryRepresentation_should_return_new_instance() + { + // Arrange + var representation1 = DictionaryRepresentation.Document; + var representation2 = DictionaryRepresentation.ArrayOfDocuments; + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(representation1); + var configurableSerializer = (IDictionaryRepresentationConfigurable)serializer; + + // Act + var result = configurableSerializer.WithDictionaryRepresentation(representation2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.Should().BeOfType, string, int>>(); + var typedResult = (ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>)result; + typedResult.DictionaryRepresentation.Should().Be(representation2); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_ChildSerializers_should_return_key_and_value_serializers() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + var configurableSerializer = (IMultipleChildSerializersConfigurable)serializer; + + // Act + var childSerializers = configurableSerializer.ChildSerializers; + + // Assert + childSerializers.Should().NotBeNull(); + childSerializers.Should().HaveCount(2); + childSerializers[0].Should().BeSameAs(keySerializer); + childSerializers[1].Should().BeSameAs(valueSerializer); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_return_new_instance_when_serializers_are_different() + { + // Arrange + var keySerializer1 = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var keySerializer2 = new StringSerializer(); + var valueSerializer2 = new Int32Serializer(BsonType.String); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer1, valueSerializer1); + var configurableSerializer = (IMultipleChildSerializersConfigurable)serializer; + + // Act + var result = configurableSerializer.WithChildSerializers([keySerializer2, valueSerializer2]); + + // Assert + result.Should().NotBeSameAs(serializer); + result.Should().BeOfType, string, int>>(); + var typedResult = (ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>)result; + typedResult.KeySerializer.Should().BeSameAs(keySerializer2); + typedResult.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_return_same_instance_when_serializers_are_equal() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, valueSerializer); + var configurableSerializer = (IMultipleChildSerializersConfigurable)serializer; + + // Act + var result = configurableSerializer.WithChildSerializers([keySerializer, valueSerializer]); + + // Assert + result.Should().BeSameAs(serializer); + } + + [Fact] + public void IMultipleChildSerializersConfigurable_WithChildSerializers_should_throw_when_array_length_is_not_2() + { + // Arrange + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(); + var configurableSerializer = (IMultipleChildSerializersConfigurable)serializer; + + // Act + Action act = () => configurableSerializer.WithChildSerializers([new StringSerializer()]); + + // Assert + act.ShouldThrow().WithMessage("Wrong number of child serializers passed."); + } + + [Fact] + public void WithDictionaryRepresentation_should_return_new_instance_when_representation_is_different() + { + // Arrange + var representation1 = DictionaryRepresentation.Document; + var representation2 = DictionaryRepresentation.ArrayOfDocuments; + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(representation1); + + // Act + var result = serializer.WithDictionaryRepresentation(representation2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(representation2); + result.KeySerializer.Should().BeSameAs(serializer.KeySerializer); + result.ValueSerializer.Should().BeSameAs(serializer.ValueSerializer); + } + + [Fact] + public void WithDictionaryRepresentation_should_return_same_instance_when_representation_is_same() + { + // Arrange + var representation = DictionaryRepresentation.Document; + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>(representation); + + // Act + var result = serializer.WithDictionaryRepresentation(representation); + + // Assert + result.Should().BeSameAs(serializer); + } + [Fact] + public void WithDictionaryRepresentation_with_serializers_should_return_new_instance_when_key_serializer_is_different() + { + // Arrange + var representation = DictionaryRepresentation.Document; + var keySerializer1 = new StringSerializer(); + var keySerializer2 = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + representation, keySerializer1, valueSerializer); + + // Act + var result = serializer.WithDictionaryRepresentation(representation, keySerializer2, valueSerializer); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(representation); + result.KeySerializer.Should().BeSameAs(keySerializer2); + result.ValueSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void WithDictionaryRepresentation_with_serializers_should_return_new_instance_when_representation_is_different() + { + // Arrange + var representation1 = DictionaryRepresentation.Document; + var representation2 = DictionaryRepresentation.ArrayOfDocuments; + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + representation1, keySerializer, valueSerializer); + + // Act + var result = serializer.WithDictionaryRepresentation(representation2, keySerializer, valueSerializer); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(representation2); + result.KeySerializer.Should().BeSameAs(keySerializer); + result.ValueSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void WithDictionaryRepresentation_with_serializers_should_return_new_instance_when_value_serializer_is_different() + { + // Arrange + var representation = DictionaryRepresentation.Document; + var keySerializer = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var valueSerializer2 = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + representation, keySerializer, valueSerializer1); + + // Act + var result = serializer.WithDictionaryRepresentation(representation, keySerializer, valueSerializer2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(representation); + result.KeySerializer.Should().BeSameAs(keySerializer); + result.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void WithDictionaryRepresentation_with_serializers_should_return_same_instance_when_all_parameters_are_same() + { + // Arrange + var representation = DictionaryRepresentation.Document; + var keySerializer = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + representation, keySerializer, valueSerializer); + + // Act + var result = serializer.WithDictionaryRepresentation(representation, keySerializer, valueSerializer); + + // Assert + result.Should().BeSameAs(serializer); + } + [Fact] + public void WithKeySerializer_should_return_new_instance_when_serializer_is_different() + { + // Arrange + var keySerializer1 = new StringSerializer(); + var keySerializer2 = new StringSerializer(); + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer1, valueSerializer); + + // Act + var result = serializer.WithKeySerializer(keySerializer2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + result.KeySerializer.Should().BeSameAs(keySerializer2); + result.ValueSerializer.Should().BeSameAs(valueSerializer); + } + + [Fact] + public void WithKeySerializer_should_return_same_instance_when_serializer_is_same() + { + // Arrange + var keySerializer = new StringSerializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, new Int32Serializer()); + + // Act + var result = serializer.WithKeySerializer(keySerializer); + + // Assert + result.Should().BeSameAs(serializer); + } + [Fact] + public void WithValueSerializer_should_return_new_instance_when_serializer_is_different() + { + // Arrange + var keySerializer = new StringSerializer(); + var valueSerializer1 = new Int32Serializer(); + var valueSerializer2 = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, keySerializer, valueSerializer1); + + // Act + var result = serializer.WithValueSerializer(valueSerializer2); + + // Assert + result.Should().NotBeSameAs(serializer); + result.DictionaryRepresentation.Should().Be(DictionaryRepresentation.Document); + result.KeySerializer.Should().BeSameAs(keySerializer); + result.ValueSerializer.Should().BeSameAs(valueSerializer2); + } + + [Fact] + public void WithValueSerializer_should_return_same_instance_when_serializer_is_same() + { + // Arrange + var valueSerializer = new Int32Serializer(); + var serializer = new ReadOnlyDictionaryInterfaceImplementerSerializer, string, int>( + DictionaryRepresentation.Document, new StringSerializer(), valueSerializer); + + // Act + var result = serializer.WithValueSerializer(valueSerializer); + + // Assert + result.Should().BeSameAs(serializer); + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/RegexSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/RegexSerializerTests.cs index f8c64f462e9..8f12ed5daee 100644 --- a/tests/MongoDB.Bson.Tests/Serialization/Serializers/RegexSerializerTests.cs +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/RegexSerializerTests.cs @@ -13,14 +13,119 @@ * limitations under the License. */ +using System; +using System.Text.RegularExpressions; using FluentAssertions; +using MongoDB.Bson.IO; +using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; +using Moq; using Xunit; namespace MongoDB.Bson.Tests.Serialization.Serializers { public class RegexSerializerTests { + [Theory] + [InlineData(BsonType.Array)] + [InlineData(BsonType.Boolean)] + [InlineData(BsonType.DateTime)] + [InlineData(BsonType.Document)] + [InlineData(BsonType.Int32)] + public void Constructor_with_invalid_representation_should_throw(BsonType representation) + { + // Act + Action act = () => new RegexSerializer(representation); + + // Assert + act.ShouldThrow() + .WithMessage($"{representation} is not a valid representation for an RegexSerializer."); + } + + [Theory] + [InlineData(BsonType.RegularExpression)] + [InlineData(BsonType.String)] + public void Constructor_with_valid_representation_should_initialize_instance(BsonType representation) + { + // Act + var subject = new RegexSerializer(representation); + + // Assert + subject.Representation.Should().Be(representation); + } + + [Fact] + public void Constructor_without_parameters_should_use_RegularExpression_representation() + { + // Act + var subject = new RegexSerializer(); + + // Assert + subject.Representation.Should().Be(BsonType.RegularExpression); + } + + [Fact] + public void Deserialize_with_invalid_BsonType_should_throw() + { + // Arrange + var subject = new RegexSerializer(); + var context = BsonDeserializationContext.CreateRoot(CreateBsonReaderWithValue(BsonType.Int32)); + + // Act + Action act = () => subject.Deserialize(context, new()); + + // Assert + act.ShouldThrow() + .WithMessage("Cannot deserialize a 'Regex' from BsonType 'Int32'."); + } + + [Fact] + public void Deserialize_with_null_should_return_null() + { + // Arrange + var subject = new RegexSerializer(); + var context = BsonDeserializationContext.CreateRoot(CreateBsonReaderWithValue(BsonType.Null)); + + // Act + var result = subject.Deserialize(context, new()); + + // Assert + result.Should().BeNull(); + } + + [Fact] + public void Deserialize_with_RegularExpression_should_return_regex() + { + // Arrange + var subject = new RegexSerializer(); + var bsonRegex = new BsonRegularExpression("pattern", "i"); + var context = BsonDeserializationContext.CreateRoot(CreateBsonReaderWithValue(BsonType.RegularExpression, bsonRegex)); + + // Act + var result = subject.Deserialize(context, new()); + + // Assert + result.Should().NotBeNull(); + result.Options.Should().Be(RegexOptions.IgnoreCase); + result.ToString().Should().Contain("pattern"); + } + + [Fact] + public void Deserialize_with_String_should_return_regex() + { + // Arrange + var subject = new RegexSerializer(); + var pattern = "pattern"; + var context = BsonDeserializationContext.CreateRoot(CreateBsonReaderWithValue(BsonType.String, pattern)); + + // Act + var result = subject.Deserialize(context, new()); + + // Assert + result.Should().NotBeNull(); + result.ToString().Should().Contain(pattern); + } + [Fact] public void Equals_null_should_return_false() { @@ -52,6 +157,34 @@ public void Equals_self_should_return_true() result.Should().Be(true); } + [Fact] + public void Equals_with_different_representation_should_return_false() + { + // Arrange + var subject1 = new RegexSerializer(BsonType.RegularExpression); + var subject2 = new RegexSerializer(BsonType.String); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_with_different_type_should_return_false() + { + // Arrange + var subject = new RegexSerializer(); + var other = new object(); + + // Act + var result = subject.Equals(other); + + // Assert + result.Should().BeFalse(); + } + [Fact] public void Equals_with_equal_fields_should_return_true() { @@ -74,6 +207,46 @@ public void Equals_with_not_equal_field_should_return_false() result.Should().Be(false); } + [Fact] + public void Equals_with_null_should_return_false() + { + // Arrange + var subject = new RegexSerializer(); + + // Act + var result = subject.Equals(null); + + // Assert + result.Should().BeFalse(); + } + + [Fact] + public void Equals_with_same_instance_should_return_true() + { + // Arrange + var subject = new RegexSerializer(); + + // Act + var result = subject.Equals(subject); + + // Assert + result.Should().BeTrue(); + } + + [Fact] + public void Equals_with_same_representation_should_return_true() + { + // Arrange + var subject1 = new RegexSerializer(BsonType.RegularExpression); + var subject2 = new RegexSerializer(BsonType.RegularExpression); + + // Act + var result = subject1.Equals(subject2); + + // Assert + result.Should().BeTrue(); + } + [Fact] public void GetHashCode_should_return_zero() { @@ -83,5 +256,126 @@ public void GetHashCode_should_return_zero() result.Should().Be(0); } + + [Fact] + public void IRepresentationConfigurable_WithRepresentation_should_return_correct_instance() + { + // Arrange + IRepresentationConfigurable subject = new RegexSerializer(BsonType.RegularExpression); + + // Act + var result = subject.WithRepresentation(BsonType.String); + + // Assert + result.Should().BeOfType(); + ((RegexSerializer)result).Representation.Should().Be(BsonType.String); + } + + [Fact] + public void RegularExpressionInstance_should_return_cached_instance() + { + // Act + var instance = RegexSerializer.RegularExpressionInstance; + + // Assert + instance.Should().NotBeNull(); + instance.Representation.Should().Be(BsonType.RegularExpression); + } + + [Fact] + public void Serialize_with_null_value_should_write_null() + { + // Arrange + var subject = new RegexSerializer(); + var writerMock = new Mock(); + var context = BsonSerializationContext.CreateRoot(writerMock.Object); + var args = new BsonSerializationArgs(); + + // Act + subject.Serialize(context, args, null); + + // Assert + writerMock.Verify(x => x.WriteNull(), Times.Once); + } + + [Fact] + public void Serialize_with_RegularExpression_representation_should_write_regex() + { + // Arrange + var subject = new RegexSerializer(BsonType.RegularExpression); + var writerMock = new Mock(); + var context = BsonSerializationContext.CreateRoot(writerMock.Object); + var regex = new Regex("pattern"); + + // Act + subject.Serialize(context, new(), regex); + + // Assert + writerMock.Verify(x => x.WriteRegularExpression(It.IsAny()), Times.Once); + } + + [Fact] + public void Serialize_with_String_representation_should_write_string() + { + // Arrange + var subject = new RegexSerializer(BsonType.String); + var writerMock = new Mock(); + var context = BsonSerializationContext.CreateRoot(writerMock.Object); + var regex = new Regex("pattern"); + + // Act + subject.Serialize(context, new(), regex); + + // Assert + writerMock.Verify(x => x.WriteString(regex.ToString()), Times.Once); + } + + [Fact] + public void WithRepresentation_with_different_representation_should_return_new_instance() + { + // Arrange + var subject = new RegexSerializer(BsonType.RegularExpression); + + // Act + var result = subject.WithRepresentation(BsonType.String); + + // Assert + result.Should().NotBeSameAs(subject); + result.Representation.Should().Be(BsonType.String); + } + + [Fact] + public void WithRepresentation_with_same_representation_should_return_same_instance() + { + // Arrange + var subject = new RegexSerializer(BsonType.RegularExpression); + + // Act + var result = subject.WithRepresentation(BsonType.RegularExpression); + + // Assert + result.Should().BeSameAs(subject); + } + + private IBsonReader CreateBsonReaderWithValue(BsonType bsonType, object value = null) + { + var readerMock = new Mock(); + readerMock.Setup(r => r.GetCurrentBsonType()).Returns(bsonType); + + if (bsonType == BsonType.Null) + { + readerMock.Setup(r => r.ReadNull()); + } + else if (bsonType == BsonType.RegularExpression) + { + readerMock.Setup(r => r.ReadRegularExpression()).Returns((BsonRegularExpression)value); + } + else if (bsonType == BsonType.String) + { + readerMock.Setup(r => r.ReadString()).Returns((string)value); + } + + return readerMock.Object; + } } } diff --git a/tests/MongoDB.Bson.Tests/Serialization/Serializers/TupleSerializerTests.cs b/tests/MongoDB.Bson.Tests/Serialization/Serializers/TupleSerializerTests.cs new file mode 100644 index 00000000000..02cf2048175 --- /dev/null +++ b/tests/MongoDB.Bson.Tests/Serialization/Serializers/TupleSerializerTests.cs @@ -0,0 +1,130 @@ +/* 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; +using System.Linq; +using FluentAssertions; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Serializers; +using Xunit; + +namespace MongoDB.Bson.Tests.Serialization.Serializers +{ + public class TupleSerializerTests + { + [Fact] + public void Create_should_create_tuple_serializer_with_correct_type() + { + // Arrange + var serializers = new IBsonSerializer[] { new Int32Serializer(), new StringSerializer() }; + + // Act + var result = TupleSerializer.Create(serializers); + + // Assert + result.Should().NotBeNull(); + result.Should().BeOfType(typeof(TupleSerializer)); + var tupleSerializer = (IBsonTupleSerializer)result; + tupleSerializer.GetItemSerializer(1).Should().BeOfType(); + tupleSerializer.GetItemSerializer(2).Should().BeOfType(); + } + + [Theory] + [InlineData(0)] + [InlineData(9)] + public void Create_should_throw_for_invalid_number_of_items(int itemCount) + { + // Arrange + IBsonSerializer[] serializers = [.. Enumerable.Range(0, itemCount).Select(_ => new Int32Serializer())]; + + // Act + Action act = () => TupleSerializer.Create(serializers); + + // Assert + act.ShouldThrow().WithMessage("Invalid number of Tuple items : *"); + } + + [Theory] + [InlineData("Item1", 1, true)] + [InlineData("Item2", 2, true)] + [InlineData("Item10", 10, true)] + [InlineData("Rest", 8, true)] + [InlineData("NotAnItem", 0, false)] + [InlineData("Item", 0, false)] + public void TryParseItemName_should_handle_item_names_correctly(string itemName, int expectedItemNumber, bool expectedResult) + { + // Act + var result = TupleSerializer.TryParseItemName(itemName, out var itemNumber); + + // Assert + result.Should().Be(expectedResult); + if (expectedResult) + { + itemNumber.Should().Be(expectedItemNumber); + } + } + + [Fact] + public void TupleSerializer_T1_should_throw_when_item1_serializer_is_null() + { + // Act + Action act = () => new TupleSerializer((IBsonSerializer)null); + + // Assert + act.ShouldThrow() + .And.ParamName.Should().Be("item1Serializer"); + } + + [Fact] + public void TupleSerializer_T1_should_initialize_item_serializers() + { + // Arrange + var item1Serializer = new Int32Serializer(); + + // Act + var serializer = new TupleSerializer(item1Serializer); + + // Assert + serializer.Item1Serializer.Should().BeSameAs(item1Serializer); + } + + [Fact] + public void TupleSerializer_T1_GetItemSerializer_should_return_correct_serializer() + { + // Arrange + var item1Serializer = new Int32Serializer(); + var serializer = new TupleSerializer(item1Serializer); + + // Act & Assert + serializer.GetItemSerializer(1).Should().BeSameAs(item1Serializer); + } + + [Theory] + [InlineData(0)] + [InlineData(2)] + public void TupleSerializer_T1_GetItemSerializer_should_throw_for_invalid_item_number(int itemNumber) + { + // Arrange + var serializer = new TupleSerializer(new Int32Serializer()); + + // Act + Action act = () => serializer.GetItemSerializer(itemNumber); + + // Assert + act.ShouldThrow() + .And.Message.Should().Be("itemNumber"); + } + } +}