public void Deserialize_should_throw_when_representation_is_binary_and_sub_type_does_not_match(
GuidRepresentationMode defaultGuidRepresentationMode,
GuidRepresentation defaultGuidRepresentation,
GuidRepresentation serializerGuidRepresentation,
GuidRepresentation?readerGuidRepresentation,
BsonBinarySubType expectedSubType)
{
GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation);
var subject = new GuidSerializer(serializerGuidRepresentation);
var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var nonMatchingSubType = expectedSubType == BsonBinarySubType.UuidLegacy ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy;
documentBytes[11] = (byte)nonMatchingSubType;
var readerSettings = new BsonBinaryReaderSettings();
if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && readerGuidRepresentation.HasValue)
{
#pragma warning disable 618
readerSettings.GuidRepresentation = readerGuidRepresentation.Value;
#pragma warning restore 618
}
var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings);
reader.ReadStartDocument();
reader.ReadName("x");
var context = BsonDeserializationContext.CreateRoot(reader);
var args = new BsonDeserializationArgs();
var exception = Record.Exception(() => subject.Deserialize(context, args));
exception.Should().BeOfType <FormatException>();
}
public void Deserializer_should_return_expected_result_when_representation_is_binary(
GuidRepresentationMode defaultGuidRepresentationMode,
GuidRepresentation defaultGuidRepresentation,
GuidRepresentation serializerGuidRepresentation,
GuidRepresentation readerGuidRepresentation,
GuidRepresentation expectedGuidRepresentation)
{
GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation);
var subject = new GuidSerializer(serializerGuidRepresentation);
var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var documentSubType = GuidConverter.GetSubType(expectedGuidRepresentation);
documentBytes[11] = (byte)documentSubType;
var readerSettings = new BsonBinaryReaderSettings();
if (defaultGuidRepresentationMode == GuidRepresentationMode.V2)
{
#pragma warning disable 618
readerSettings.GuidRepresentation = readerGuidRepresentation;
#pragma warning restore 618
}
var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings);
reader.ReadStartDocument();
reader.ReadName("x");
var context = BsonDeserializationContext.CreateRoot(reader);
var args = new BsonDeserializationArgs();
var result = subject.Deserialize(context, args);
var guidBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
var expectedGuid = GuidConverter.FromBytes(guidBytes, expectedGuidRepresentation);
result.Should().Be(expectedGuid);
}
public void Serialize_should_throw_when_effectiveGuidRepresentation_is_Unspecified(
GuidRepresentationMode defaultGuidRepresentationMode,
GuidRepresentation defaultGuidRepresentation,
GuidRepresentation serializerGuidRepresentation,
GuidRepresentation?writerGuidRepresentation)
{
GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation);
var subject = new GuidSerializer(serializerGuidRepresentation);
var memoryStream = new MemoryStream();
var writerSettings = new BsonBinaryWriterSettings();
if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && writerGuidRepresentation.HasValue)
{
#pragma warning disable 618
writerSettings.GuidRepresentation = writerGuidRepresentation.Value;
#pragma warning restore 618
}
var writer = new BsonBinaryWriter(memoryStream, writerSettings);
var context = BsonSerializationContext.CreateRoot(writer);
var args = new BsonSerializationArgs();
var value = new Guid("01020304-0506-0708-090a-0b0c0d0e0f10");
writer.WriteStartDocument();
writer.WriteName("x");
var exception = Record.Exception(() => subject.Serialize(context, args, value));
exception.Should().BeOfType <BsonSerializationException>();
}
public void Deserialize_binary_data_should_throw_when_guid_representation_is_specified_and_sub_type_is_not_expected_sub_type(
[ClassValues(typeof(GuidModeValues))]
GuidMode mode,
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy, GuidRepresentation.Standard)]
GuidRepresentation readerGuidRepresentation,
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy, GuidRepresentation.Standard)]
GuidRepresentation guidRepresentation)
{
#pragma warning disable 618
mode.Set();
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
var subject = new ObjectSerializer(discriminatorConvention, guidRepresentation);
var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var incorrectSubType = guidRepresentation == GuidRepresentation.Standard ? BsonBinarySubType.UuidLegacy : BsonBinarySubType.UuidStandard;
bytes[11] = (byte)incorrectSubType;
var readerSettings = new BsonBinaryReaderSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
readerSettings.GuidRepresentation = readerGuidRepresentation;
}
using (var memoryStream = new MemoryStream(bytes))
using (var reader = new BsonBinaryReader(memoryStream, readerSettings))
{
var context = BsonDeserializationContext.CreateRoot(reader);
reader.ReadStartDocument();
reader.ReadName("x");
var exception = Record.Exception(() => subject.Deserialize <object>(context));
exception.Should().BeOfType <FormatException>();
}
#pragma warning restore 618
}
public void TestGuid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618, 1062
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
var document = new BsonDocument
{
{ "guid", new Guid("B5F21E0C2A0D42d6AD03D827008D8AB6") }
};
using (var bsonReader = new BsonDocumentReader(document))
{
var rehydrated = DeserializeBsonDocument(bsonReader);
Assert.True(document.Equals(rehydrated));
}
}
else
{
var exception = Record.Exception(() => new BsonDocument("guid", new Guid("B5F21E0C2A0D42d6AD03D827008D8AB6")));
exception.Should().BeOfType <InvalidOperationException>();
}
#pragma warning restore 618, 1062
}
public void Explicit_decoding_with_standard_representation_should_work_as_expected()
{
GuidMode.Set(GuidRepresentationMode.V3);
var guid = new Guid("00112233445566778899aabbccddeeff");
var bytes = GuidConverter.ToBytes(guid, GuidRepresentation.Standard);
var binaryData = new BsonBinaryData(bytes, BsonBinarySubType.UuidStandard);
var exception = Record.Exception(() => binaryData.ToGuid(GuidRepresentation.Unspecified));
exception.Should().BeOfType <ArgumentException>();
foreach (var guidRepresentation in new[] { GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy })
{
exception = Record.Exception(() => binaryData.ToGuid(guidRepresentation));
exception.Should().BeOfType <InvalidOperationException>();
}
var result = binaryData.ToGuid();
result.Should().Be(guid);
result = binaryData.ToGuid(GuidRepresentation.Standard);
result.Should().Be(guid);
}
public void constructor_should_throw_when_sub_type_is_uuid_and_guid_representation_is_invalid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode,
[Values(5)] GuidRepresentation guidRepresentation,
[Range(1, 2)] int overload)
{
mode.Set();
#pragma warning disable 618
var bytes = new byte[16];
var guid = Guid.Empty;
Exception exception = null;
switch (overload)
{
case 1: exception = Record.Exception(() => new BsonBinaryData(bytes, BsonBinarySubType.UuidLegacy, guidRepresentation)); break;
case 2: exception = Record.Exception(() => new BsonBinaryData(guid, guidRepresentation)); break;
}
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 || overload == 2)
{
var e = exception.Should().BeOfType <ArgumentException>().Subject;
e.Message.Should().StartWith($"Invalid guidRepresentation: 5.");
e.ParamName.Should().Be("guidRepresentation");
}
else
{
exception.Should().BeOfType <InvalidOperationException>();
}
#pragma warning restore 618
}
public void Deserialize_binary_data_should_return_expected_result_when_guid_representation_is_specified(
[ClassValues(typeof(GuidModeValues))]
GuidMode mode,
[Values(-1, GuidRepresentation.Unspecified)]
GuidRepresentation readerGuidRepresentation,
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy, GuidRepresentation.Standard)]
GuidRepresentation guidRepresentation)
{
#pragma warning disable 618
mode.Set();
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
var subject = new ObjectSerializer(discriminatorConvention, guidRepresentation);
var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var subType = GuidConverter.GetSubType(guidRepresentation);
bytes[11] = (byte)subType;
var readerSettings = new BsonBinaryReaderSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
readerSettings.GuidRepresentation = readerGuidRepresentation == (GuidRepresentation)(-1) ? guidRepresentation : GuidRepresentation.Unspecified;
}
using (var memoryStream = new MemoryStream(bytes))
using (var reader = new BsonBinaryReader(memoryStream, readerSettings))
{
var context = BsonDeserializationContext.CreateRoot(reader);
reader.ReadStartDocument();
reader.ReadName("x");
var result = subject.Deserialize <object>(context);
var guidBytes = bytes.Skip(12).Take(16).ToArray();
var expectedResult = GuidConverter.FromBytes(guidBytes, guidRepresentation);
result.Should().Be(expectedResult);
}
#pragma warning restore 618
}
public void Deserialize_should_throw_when_representation_is_binary_and_guid_representation_is_unspecified(
GuidRepresentationMode defaultGuidRepresentationMode,
GuidRepresentation defaultGuidRepresentation,
GuidRepresentation?readerGuidRepresentation)
{
GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation);
var subject = new GuidSerializer(GuidRepresentation.Unspecified);
var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var readerSettings = new BsonBinaryReaderSettings();
if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && readerGuidRepresentation.HasValue)
{
#pragma warning disable 618
readerSettings.GuidRepresentation = readerGuidRepresentation.Value;
#pragma warning restore 618
}
var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings);
reader.ReadStartDocument();
reader.ReadName("x");
var context = BsonDeserializationContext.CreateRoot(reader);
var args = new BsonDeserializationArgs();
var exception = Record.Exception(() => subject.Deserialize(context, args));
exception.Should().BeOfType <BsonSerializationException>();
}
public void Serialize_should_not_convert_Uuids_in_elements(
[ClassValues(typeof(GuidModeValues))] GuidMode mode,
[Values(false, true)] bool useGenericInterface)
{
mode.Set();
var guid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
var value = new BsonDocument {
{ "_id", new BsonBinaryData(guid, GuidRepresentation.Standard) }, { "x", 1 }
};
var elements = new BsonDocument("b", new BsonBinaryData(guid, GuidRepresentation.Standard));
var subject = CreateSubject(elements);
string result;
using (var textWriter = new StringWriter())
using (var writer = new JsonWriter(textWriter, new JsonWriterSettings()))
{
var context = BsonSerializationContext.CreateRoot(writer);
var args = new BsonSerializationArgs {
NominalType = typeof(BsonDocument)
};
if (useGenericInterface)
{
subject.Serialize(context, args, value);
}
else
{
((IBsonSerializer)subject).Serialize(context, args, value);
}
result = textWriter.ToString();
}
// note that "_id" was converted but "b" was not
string expectedIdJson;
#pragma warning disable 618
var guidRepresentation = BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 ? BsonDefaults.GuidRepresentation : GuidRepresentation.Unspecified;
switch (guidRepresentation)
{
case GuidRepresentation.CSharpLegacy: expectedIdJson = "CSUUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\")"; break;
case GuidRepresentation.JavaLegacy: expectedIdJson = "JUUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\")"; break;
case GuidRepresentation.PythonLegacy: expectedIdJson = "PYUUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\")"; break;
case GuidRepresentation.Standard: expectedIdJson = "UUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\")"; break;
case GuidRepresentation.Unspecified: expectedIdJson = "UUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\")"; break;
default: throw new Exception("Unexpected GuidRepresentation.");
}
#pragma warning restore 618
result.Should().Be($"{{ \"_id\" : {expectedIdJson}, \"x\" : 1, \"b\" : UUID(\"01020304-0506-0708-090a-0b0c0d0e0f10\") }}");
}
public void BsonBinaryData_constructor_with_a_Guid_and_a_representation_should_return_expected_result(GuidRepresentation guidRepresentation, BsonBinarySubType expectedSubType, string expectedBytes)
{
GuidMode.Set(GuidRepresentationMode.V3);
var guid = new Guid("00112233445566778899aabbccddeeff");
var result = new BsonBinaryData(guid, guidRepresentation);
result.SubType.Should().Be(expectedSubType);
result.Bytes.Should().Equal(BsonUtils.ParseHexString(expectedBytes));
}
public void BsonBinaryData_constructor_with_a_Guid_and_representation_Unspecified_should_throw()
{
GuidMode.Set(GuidRepresentationMode.V3);
var guid = new Guid("00112233445566778899aabbccddeeff");
#pragma warning disable 618
var exception = Record.Exception(() => new BsonBinaryData(guid, GuidRepresentation.Unspecified));
#pragma warning disable 618
exception.Should().BeOfType <InvalidOperationException>();
}
public void SerializeValue_should_throw_when_value_representation_is_unspecified(
[ClassValues(typeof(GuidModeValues))] GuidMode mode,
[Values(
GuidRepresentation.CSharpLegacy,
GuidRepresentation.JavaLegacy,
GuidRepresentation.PythonLegacy,
GuidRepresentation.Standard,
GuidRepresentation.Unspecified)] GuidRepresentation writerGuidRepresentation,
[Values(
GuidRepresentation.CSharpLegacy,
GuidRepresentation.JavaLegacy,
GuidRepresentation.PythonLegacy,
GuidRepresentation.Standard,
GuidRepresentation.Unspecified)] GuidRepresentation valueGuidRepresentation)
{
mode.Set();
#pragma warning disable 618
var subject = new BsonBinaryDataSerializer();
var mockWriter = new Mock <IBsonWriter>();
var writerSettings = new BsonBinaryWriterSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
writerSettings.GuidRepresentation = writerGuidRepresentation;
}
mockWriter.SetupGet(m => m.Settings).Returns(writerSettings);
var context = BsonSerializationContext.CreateRoot(mockWriter.Object);
var args = new BsonSerializationArgs();
var subType = valueGuidRepresentation == GuidRepresentation.Unspecified ? BsonBinarySubType.UuidLegacy : GuidConverter.GetSubType(valueGuidRepresentation);
var value = BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2
? new BsonBinaryData(new byte[16], subType, valueGuidRepresentation)
: new BsonBinaryData(new byte[16], subType);
var exception = Record.Exception(() => subject.Serialize(context, args, value));
var isExceptionExpected =
BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 &&
writerGuidRepresentation != GuidRepresentation.Unspecified &&
valueGuidRepresentation == GuidRepresentation.Unspecified;
if (isExceptionExpected)
{
var e = exception.Should().BeOfType <BsonSerializationException>().Subject;
e.Message.Should().Contain("Cannot serialize BsonBinaryData with GuidRepresentation Unspecified");
}
else
{
exception.Should().BeNull();
}
#pragma warning restore 618
}
public void TestBinaryStrict(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var guid = Guid.Parse("00112233-4455-6677-8899-aabbccddeeff");
var tests = new List <TestData <BsonBinaryData> >
{
new TestData <BsonBinaryData>(new byte[] { }, "{ \"$binary\" : \"\", \"$type\" : \"00\" }"),
new TestData <BsonBinaryData>(new byte[] { 1 }, "{ \"$binary\" : \"AQ==\", \"$type\" : \"00\" }"),
new TestData <BsonBinaryData>(new byte[] { 1, 2 }, "{ \"$binary\" : \"AQI=\", \"$type\" : \"00\" }"),
new TestData <BsonBinaryData>(new byte[] { 1, 2, 3 }, "{ \"$binary\" : \"AQID\", \"$type\" : \"00\" }")
};
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
byte[] expectedBytes;
string expectedSubType;
switch (BsonDefaults.GuidRepresentation)
{
case GuidRepresentation.CSharpLegacy:
case GuidRepresentation.JavaLegacy:
case GuidRepresentation.PythonLegacy:
expectedBytes = GuidConverter.ToBytes(guid, BsonDefaults.GuidRepresentation);
expectedSubType = "03";
break;
case GuidRepresentation.Standard:
expectedBytes = GuidConverter.ToBytes(guid, GuidRepresentation.Standard);
expectedSubType = "04";
break;
default: throw new Exception("Invalid GuidRepresentation.");
}
var expectedBase64 = Convert.ToBase64String(expectedBytes);
var expectedGuidJson = $"{{ \"$binary\" : \"{expectedBase64}\", \"$type\" : \"{expectedSubType}\" }}";
tests.Add(new TestData <BsonBinaryData>(guid, expectedGuidJson));
}
var jsonSettings = new JsonWriterSettings {
OutputMode = JsonOutputMode.Strict
};
foreach (var test in tests)
{
var json = test.Value.ToJson(jsonSettings);
Assert.Equal(test.Expected, json);
Assert.Equal(test.Value, BsonSerializer.Deserialize <BsonBinaryData>(new JsonReader(json, new JsonReaderSettings())));
}
#pragma warning restore 618
}
public void Serialize_should_configure_GuidRepresentation(
[ClassValues(typeof(GuidModeValues))] GuidMode mode,
[Values(false, true)] bool useGenericInterface)
{
mode.Set();
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
var mockDocumentSerializer = new Mock <IBsonSerializer <BsonDocument> >();
var writerSettingsConfigurator = (Action <BsonWriterSettings>)(s => s.GuidRepresentation = GuidRepresentation.Unspecified);
var subject = new ElementAppendingSerializer <BsonDocument>(mockDocumentSerializer.Object, new BsonElement[0], writerSettingsConfigurator);
var stream = new MemoryStream();
var settings = new BsonBinaryWriterSettings {
GuidRepresentation = GuidRepresentation.CSharpLegacy
};
var writer = new BsonBinaryWriter(stream, settings);
var context = BsonSerializationContext.CreateRoot(writer);
var args = new BsonSerializationArgs {
NominalType = typeof(BsonDocument)
};
var value = new BsonDocument();
GuidRepresentation?capturedGuidRepresentation = null;
mockDocumentSerializer
.Setup(m => m.Serialize(It.IsAny <BsonSerializationContext>(), args, value))
.Callback((BsonSerializationContext c, BsonSerializationArgs a, BsonDocument v) =>
{
var elementAppendingWriter = (ElementAppendingBsonWriter)c.Writer;
var configurator = elementAppendingWriter._settingsConfigurator();
var configuredSettings = new BsonBinaryWriterSettings {
GuidRepresentation = GuidRepresentation.CSharpLegacy
};
configurator(configuredSettings);
capturedGuidRepresentation = configuredSettings.GuidRepresentation;
});
if (useGenericInterface)
{
subject.Serialize(context, args, value);
}
else
{
((IBsonSerializer)subject).Serialize(context, args, value);
}
capturedGuidRepresentation.Should().Be(GuidRepresentation.Unspecified);
}
#pragma warning restore 618
}
public void Deserialize_should_return_expected_result_when_representation_is_string(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
var subject = new GuidSerializer(BsonType.String);
var json = "\"01020304-0506-0708-090a-0b0c0d0e0f10\"";
var reader = new JsonReader(json, new JsonReaderSettings());
var context = BsonDeserializationContext.CreateRoot(reader);
var args = new BsonDeserializationArgs();
var result = subject.Deserialize(context, args);
result.Should().Be(new Guid("01020304-0506-0708-090a-0b0c0d0e0f10"));
}
public void Implicit_encoding_with_unspecified_representation_should_work_as_expected()
{
GuidMode.Set(GuidRepresentationMode.V3);
var collection = GetCollection <ClassWithGuidIdUsingUnspecifiedRepresentation>();
var guid = Guid.Parse("00112233445566778899aabbccddeeff");
var document = new ClassWithGuidIdUsingUnspecifiedRepresentation {
Id = guid
};
DropCollection(collection);
var exception = Record.Exception(() => collection.InsertOne(document));
exception.Should().BeOfType <BsonSerializationException>();
}
public void TestGuidRefId(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var guid = Guid.NewGuid();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation == GuidRepresentation.Unspecified ||
BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V3)
{
var exception = Record.Exception(() => new MongoDBRef("collection", guid));
exception.Should().BeOfType <InvalidOperationException>();
}
else
{
var id = ObjectId.GenerateNewId();
var dbRef = new MongoDBRef("collection", guid);
var obj = new C {
Id = id, DBRef = dbRef
};
var json = obj.ToJson();
var expected = "{ '_id' : ObjectId('#id'), 'DBRef' : { '$ref' : 'collection', '$id' : #uuidConstructorName('#guid') } }";
expected = expected.Replace("#id", id.ToString());
string uuidConstructorName;
switch (BsonDefaults.GuidRepresentation)
{
case GuidRepresentation.CSharpLegacy: uuidConstructorName = "CSUUID"; break;
case GuidRepresentation.JavaLegacy: uuidConstructorName = "JUUID"; break;
case GuidRepresentation.PythonLegacy: uuidConstructorName = "PYUUID"; break;
case GuidRepresentation.Standard: uuidConstructorName = "UUID"; break;
default: throw new Exception("Invalid GuidRepresentation.");
}
;
expected = expected.Replace("#uuidConstructorName", uuidConstructorName);
expected = expected.Replace("#guid", guid.ToString());
expected = expected.Replace("'", "\"");
Assert.Equal(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.Deserialize <C>(bson);
Assert.True(bson.SequenceEqual(rehydrated.ToBson()));
}
#pragma warning restore 618
}
public void SerializeValue_should_call_WriteBinaryData(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
var subject = new BsonBinaryDataSerializer();
var mockWriter = new Mock <IBsonWriter>();
var context = BsonSerializationContext.CreateRoot(mockWriter.Object);
var args = new BsonSerializationArgs();
var value = new BsonBinaryData(new byte[0]);
subject.Serialize(context, args, value);
mockWriter.Verify(m => m.WriteBinaryData(value), Times.Once);
}
public void Serialize_shoud_write_expected_string_when_representation_is_string(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
var subject = new GuidSerializer(BsonType.String);
var stringWriter = new StringWriter();
var writer = new JsonWriter(stringWriter);
var context = BsonSerializationContext.CreateRoot(writer);
var args = new BsonSerializationArgs();
var value = new Guid("01020304-0506-0708-090a-0b0c0d0e0f10");
subject.Serialize(context, args, value);
var result = stringWriter.ToString();
result.Should().Be("\"01020304-0506-0708-090a-0b0c0d0e0f10\"");
}
public void TestGuidJavaLegacy(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var guid = new Guid("01020304-0506-0708-090a-0b0c0d0e0f10");
var binaryData = new BsonBinaryData(guid, GuidRepresentation.JavaLegacy);
var expected = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1, 16, 15, 14, 13, 12, 11, 10, 9 };
Assert.True(expected.SequenceEqual(binaryData.Bytes));
Assert.Equal(BsonBinarySubType.UuidLegacy, binaryData.SubType);
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
Assert.Equal(GuidRepresentation.JavaLegacy, binaryData.GuidRepresentation);
Assert.Equal(guid, binaryData.AsGuid);
Assert.Equal(guid, binaryData.RawValue);
}
#pragma warning restore
}
public void ReadBinaryData_subtype_4_should_use_GuidRepresentation_Standard(
[ClassValues(typeof(GuidModeValues))] GuidMode mode,
[Values(
GuidRepresentation.CSharpLegacy,
GuidRepresentation.JavaLegacy,
GuidRepresentation.PythonLegacy,
GuidRepresentation.Standard,
GuidRepresentation.Unspecified)] GuidRepresentation guidRepresentation)
{
mode.Set();
#pragma warning disable 618
var settings = new BsonBinaryReaderSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
settings.GuidRepresentation = guidRepresentation;
}
var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
using (var stream = new MemoryStream(bytes))
using (var reader = new BsonBinaryReader(stream, settings))
{
reader.ReadStartDocument();
var type = reader.ReadBsonType();
var name = reader.ReadName();
var binaryData = reader.ReadBinaryData();
var endOfDocument = reader.ReadBsonType();
reader.ReadEndDocument();
name.Should().Be("x");
type.Should().Be(BsonType.Binary);
binaryData.SubType.Should().Be(BsonBinarySubType.UuidStandard);
binaryData.Bytes.Should().Equal(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 });
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
binaryData.GuidRepresentation.Should().Be(GuidRepresentation.Standard);
}
endOfDocument.Should().Be(BsonType.EndOfDocument);
stream.Position.Should().Be(stream.Length);
}
#pragma warning restore 618
}
public void Explicit_decoding_with_python_legacy_representation_should_work_as_expected()
{
GuidMode.Set(GuidRepresentationMode.V3);
var bytes = BsonUtils.ParseHexString("00112233445566778899aabbccddeeff");
var binaryData = new BsonBinaryData(bytes, BsonBinarySubType.UuidLegacy);
var exception = Record.Exception(() => binaryData.ToGuid());
exception.Should().BeOfType <InvalidOperationException>();
exception = Record.Exception(() => binaryData.ToGuid(GuidRepresentation.Standard));
exception.Should().BeOfType <InvalidOperationException>();
exception = Record.Exception(() => binaryData.ToGuid(GuidRepresentation.Unspecified));
exception.Should().BeOfType <ArgumentException>();
var result = binaryData.ToGuid(GuidRepresentation.PythonLegacy);
result.Should().Be(new Guid("00112233445566778899aabbccddeeff"));
}
public void TestGuid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
C c = new C {
Guid = Guid.Empty
};
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
var json = c.ToJson(new JsonWriterSettings());
string expectedGuidJson;
var guidRepresentation = BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 ? BsonDefaults.GuidRepresentation : GuidRepresentation.Unspecified;
switch (guidRepresentation)
{
case GuidRepresentation.CSharpLegacy: expectedGuidJson = "CSUUID('00000000-0000-0000-0000-000000000000')"; break;
case GuidRepresentation.JavaLegacy: expectedGuidJson = "JUUID('00000000-0000-0000-0000-000000000000')"; break;
case GuidRepresentation.PythonLegacy: expectedGuidJson = "PYUUID('00000000-0000-0000-0000-000000000000')"; break;
case GuidRepresentation.Standard: expectedGuidJson = "UUID('00000000-0000-0000-0000-000000000000')"; break;
default: throw new Exception("Unexpected GuidRepresentation.");
}
var expected = _template.Replace("'Guid' : null", $"'Guid' : {expectedGuidJson}").Replace("'", "\"");
Assert.Equal(expected, json);
var bson = c.ToBson(writerSettings: new BsonBinaryWriterSettings());
var rehydrated = BsonSerializer.Deserialize <C>(new BsonBinaryReader(new MemoryStream(bson), new BsonBinaryReaderSettings()));
Assert.True(bson.SequenceEqual(rehydrated.ToBson(writerSettings: new BsonBinaryWriterSettings())));
}
else
{
var exception = Record.Exception(() => c.ToJson(new JsonWriterSettings()));
exception.Should().BeOfType <BsonSerializationException>();
}
#pragma warning restore 618
}
public void TestAsGuid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var guid = Guid.NewGuid();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
BsonValue v = guid;
BsonValue s = "";
var g = v.AsGuid;
Assert.Equal(guid, g);
Assert.Throws <InvalidCastException>(() => { var x = s.AsGuid; });
}
else
{
var exception = Record.Exception(() => { BsonValue v = guid; });
exception.Should().BeOfType <InvalidOperationException>();
}
#pragma warning restore 618
}
public void TestBinaryShell(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var guid = Guid.Parse("00112233-4455-6677-8899-aabbccddeeff");
var tests = new List <TestData <BsonBinaryData> >
{
new TestData <BsonBinaryData>(new byte[] { }, "new BinData(0, \"\")"),
new TestData <BsonBinaryData>(new byte[] { 1 }, "new BinData(0, \"AQ==\")"),
new TestData <BsonBinaryData>(new byte[] { 1, 2 }, "new BinData(0, \"AQI=\")"),
new TestData <BsonBinaryData>(new byte[] { 1, 2, 3 }, "new BinData(0, \"AQID\")")
};
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
string expectedGuidJson;
switch (BsonDefaults.GuidRepresentation)
{
case GuidRepresentation.CSharpLegacy: expectedGuidJson = "CSUUID(\"00112233-4455-6677-8899-aabbccddeeff\")"; break;
case GuidRepresentation.JavaLegacy: expectedGuidJson = "JUUID(\"00112233-4455-6677-8899-aabbccddeeff\")"; break;
case GuidRepresentation.PythonLegacy: expectedGuidJson = "PYUUID(\"00112233-4455-6677-8899-aabbccddeeff\")"; break;
case GuidRepresentation.Standard: expectedGuidJson = "UUID(\"00112233-4455-6677-8899-aabbccddeeff\")"; break;
default: throw new Exception("Invalid GuidRepresentation.");
}
tests.Add(new TestData <BsonBinaryData>(guid, expectedGuidJson));
}
foreach (var test in tests)
{
var json = test.Value.ToJson(new JsonWriterSettings());
Assert.Equal(test.Expected, json);
Assert.Equal(test.Value, BsonSerializer.Deserialize <BsonBinaryData>(json));
}
#pragma warning restore 618
}
public void Test(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var p = new Parent {
Child = new Child()
};
p.Child.A = 1;
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
var json = p.ToJson(new JsonWriterSettings());
BsonSerializer.Deserialize <Parent>(json); // throws Unexpected element exception
}
else
{
var exception = Record.Exception(() => p.ToJson(new JsonWriterSettings()));
exception.Should().BeOfType <BsonSerializationException>();
}
#pragma warning restore 618
}
public void TestGuid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618, 1062
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation == GuidRepresentation.Unspecified ||
BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V3)
{
var exception = Record.Exception(() => new BsonDocument("guid", new Guid("00112233445566778899aabbccddeeff")));
exception.Should().BeOfType <InvalidOperationException>();
}
else
{
var document = new BsonDocument
{
{ "guid", new Guid("00112233445566778899aabbccddeeff") }
};
string expected;
var guidRepresentation = BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 ? BsonDefaults.GuidRepresentation : GuidRepresentation.Unspecified;
switch (guidRepresentation)
{
case GuidRepresentation.CSharpLegacy: expected = "{ \"guid\" : CSUUID(\"00112233-4455-6677-8899-aabbccddeeff\") }"; break;
case GuidRepresentation.JavaLegacy: expected = "{ \"guid\" : JUUID(\"00112233-4455-6677-8899-aabbccddeeff\") }"; break;
case GuidRepresentation.PythonLegacy: expected = "{ \"guid\" : PYUUID(\"00112233-4455-6677-8899-aabbccddeeff\") }"; break;
case GuidRepresentation.Standard: expected = "{ \"guid\" : UUID(\"00112233-4455-6677-8899-aabbccddeeff\") }"; break;
default: throw new Exception("Unexpected GuidRepresentation.");
}
string actual = document.ToJson(new JsonWriterSettings());
Assert.Equal(expected, actual);
}
#pragma warning restore 618, 1062
}
public void TestMapGuid(
[ClassValues(typeof(GuidModeValues))] GuidMode mode)
{
mode.Set();
#pragma warning disable 618
var value = Guid.NewGuid();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
var bsonValue = (BsonBinaryData)BsonTypeMapper.MapToBsonValue(value);
byte[] expectedBytes;
BsonBinarySubType expectedSubType;
var guidRepresentation = BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 ? BsonDefaults.GuidRepresentation : GuidRepresentation.Unspecified;
if (guidRepresentation == GuidRepresentation.Unspecified)
{
expectedBytes = GuidConverter.ToBytes(value, GuidRepresentation.Standard);
expectedSubType = BsonBinarySubType.UuidStandard;
}
else
{
expectedBytes = GuidConverter.ToBytes(value, guidRepresentation);
expectedSubType = GuidConverter.GetSubType(guidRepresentation);
}
Assert.True(expectedBytes.SequenceEqual(bsonValue.Bytes));
Assert.Equal(expectedSubType, bsonValue.SubType);
var bsonBinary = (BsonBinaryData)BsonTypeMapper.MapToBsonValue(value, BsonType.Binary);
Assert.True(expectedBytes.SequenceEqual(bsonBinary.Bytes));
Assert.Equal(expectedSubType, bsonBinary.SubType);
}
else
{
var exception = Record.Exception(() => (BsonBinaryData)BsonTypeMapper.MapToBsonValue(value));
exception.Should().BeOfType <InvalidOperationException>();
exception = Record.Exception(() => (BsonBinaryData)BsonTypeMapper.MapToBsonValue(value, BsonType.Binary));
exception.Should().BeOfType <InvalidOperationException>();
}
#pragma warning restore 618
}
public void Serialize_guid_should_have_expected_result_when_guid_representation_is_specified(
[ClassValues(typeof(GuidModeValues))]
GuidMode mode,
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy, GuidRepresentation.Standard, GuidRepresentation.Unspecified)]
GuidRepresentation writerGuidRepresentation,
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.JavaLegacy, GuidRepresentation.PythonLegacy, GuidRepresentation.Standard)]
GuidRepresentation guidRepresentation)
{
#pragma warning disable 618
mode.Set();
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
var subject = new ObjectSerializer(discriminatorConvention, guidRepresentation);
var writerSettings = new BsonBinaryWriterSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
writerSettings.GuidRepresentation = writerGuidRepresentation;
}
using (var memoryStream = new MemoryStream())
using (var writer = new BsonBinaryWriter(memoryStream, writerSettings))
{
var context = BsonSerializationContext.CreateRoot(writer);
var guid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
writer.WriteStartDocument();
writer.WriteName("x");
subject.Serialize(context, guid);
writer.WriteEndDocument();
var bytes = memoryStream.ToArray();
var expectedBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
var expectedSubType = GuidConverter.GetSubType(guidRepresentation);
var expectedGuidBytes = GuidConverter.ToBytes(guid, guidRepresentation);
expectedBytes[11] = (byte)expectedSubType;
Array.Copy(expectedGuidBytes, 0, expectedBytes, 12, 16);
bytes.Should().Equal(expectedBytes);
}
#pragma warning restore 618
}
