public static void BsonSerializeStringToBytes()
{
// Arrange
var bsonSerializer = new NaosBsonSerializer <GenericDiscoveryBsonConfiguration <string> >();
var input = A.Dummy <string>();
// Act
var bsonStringException = Record.Exception(() => bsonSerializer.SerializeToBytes(input));
// Assert
bsonStringException.Should().BeOfType <NotSupportedException>();
}
public static void ElementTypeOfArrayIsOnlyTypeDiscovered()
{
// Arrange
var bsonConfig = typeof(GenericDiscoveryBsonConfiguration <RegisteredKey, RegisteredValue>);
var bsonSerializer = new NaosBsonSerializer(bsonConfig);
var jsonConfig = typeof(GenericDiscoveryJsonConfiguration <RegisteredKey, RegisteredValue>);
var jsonSerializer = new NaosJsonSerializer(jsonConfig);
var expectedKey = new RegisteredKey {
Property = A.Dummy <string>()
};
var expectedValue = new RegisteredValue {
Property = A.Dummy <string>()
};
var expectedTuple = new Tuple <RegisteredKey, RegisteredValue>(expectedKey, expectedValue);
var expectedDictionary = new Dictionary <RegisteredKey, RegisteredValue> {
{ expectedKey, expectedValue }
};
var expectedList = new List <RegisteredKey>(new[] { expectedKey });
var expectedArray = new[] { expectedValue };
// Act
// var tupleBsonString = bsonSerializer.SerializeToString(expectedTuple);
// var tupleBson = bsonSerializer.Deserialize<Tuple<RegisteredKey, RegisteredValue>>(tupleBsonString);
var tupleJsonString = jsonSerializer.SerializeToString(expectedTuple);
var tupleJson = jsonSerializer.Deserialize <Tuple <RegisteredKey, RegisteredValue> >(tupleJsonString);
var dictionaryJsonString = jsonSerializer.SerializeToString(expectedDictionary);
var dictionaryJson = jsonSerializer.Deserialize <Dictionary <RegisteredKey, RegisteredValue> >(dictionaryJsonString);
var listJsonString = jsonSerializer.SerializeToString(expectedList);
var listJson = jsonSerializer.Deserialize <List <RegisteredKey> >(listJsonString);
var arrayJsonString = jsonSerializer.SerializeToString(expectedArray);
var arrayJson = jsonSerializer.Deserialize <RegisteredValue[]>(arrayJsonString);
// Assert
// tupleBson.Should().BeEquivalentTo(expectedTuple);
tupleJson.Item1.Property.Should().Be(expectedTuple.Item1.Property);
tupleJson.Item2.Property.Should().Be(expectedTuple.Item2.Property);
dictionaryJson.Single().Key.Property.Should().Be(expectedDictionary.Single().Key.Property);
dictionaryJson.Single().Value.Property.Should().Be(expectedDictionary.Single().Value.Property);
listJson.Single().Property.Should().Be(expectedList.Single().Property);
arrayJson.Single().Property.Should().Be(expectedArray.Single().Property);
}
public static void BsonCanSerializeNull()
{
// Arrange
var serializer = new NaosBsonSerializer();
// Act
var actualNullString = serializer.SerializeToString(null);
var actualNullBytes = serializer.SerializeToBytes(null);
var actualStringException = Record.Exception(() => serializer.SerializeToString(SerializationConfigurationBase.NullSerializedStringValue));
var actualNullFromString = serializer.Deserialize <NullableObject>(actualNullString);
var actualNullFromBytes = serializer.Deserialize <NullableObject>(actualNullBytes);
// Assert
actualNullString.Should().Be(SerializationConfigurationBase.NullSerializedStringValue);
actualNullFromString.Should().BeNull();
actualNullFromBytes.Should().BeNull();
actualStringException.Should().NotBeNull();
actualStringException.Should().BeOfType <NotSupportedException>();
}
public static void RegularColorRoundtrip()
{
// Arrange
var serializer = new NaosBsonSerializer();
var expected = new ObjectWithNetDrawingTypes
{
Color = A.Dummy <Color>(),
NullableWithValueColor = A.Dummy <Color>(),
NullableWithoutValueColor = null,
};
// Act
var actualString = serializer.SerializeToString(expected);
var actual = serializer.Deserialize <ObjectWithNetDrawingTypes>(actualString);
// Assert
actual.Color.Should().Be(expected.Color);
actual.NullableWithValueColor.Should().Be(expected.NullableWithValueColor);
actual.NullableWithoutValueColor.Should().BeNull();
}
public static void RoundtripSerializeWithCallback <T>(
this T expected,
RoundtripSerializationCallback <T> validationCallback,
Type jsonConfigType = null,
Type bsonConfigType = null,
Type propBagConfigType = null,
UnregisteredTypeEncounteredStrategy unregisteredTypeEncounteredStrategy = UnregisteredTypeEncounteredStrategy.Default,
bool testBson = true,
bool testJson = true,
bool testPropBag = false)
{
new { validationCallback }.Must().NotBeNull();
var serializers = new List <ISerializeAndDeserialize>();
if (testJson)
{
var jsonSerializer = new NaosJsonSerializer(jsonConfigType, unregisteredTypeEncounteredStrategy);
serializers.Add(jsonSerializer);
}
if (testBson)
{
var bsonSerializer = new NaosBsonSerializer(bsonConfigType, unregisteredTypeEncounteredStrategy);
serializers.Add(bsonSerializer);
}
if (testPropBag)
{
var propBagSerializer = new NaosPropertyBagSerializer(propBagConfigType, unregisteredTypeEncounteredStrategy);
serializers.Add(propBagSerializer);
}
if (!serializers.Any())
{
throw new InvalidOperationException("No serializers are being tested.");
}
foreach (var serializer in serializers)
{
var configurationTypeRepresentation = serializer.ConfigurationType.ToRepresentation();
var stringDescription = new SerializationDescription(
serializer.Kind,
SerializationFormat.String,
configurationTypeRepresentation);
var binaryDescription = new SerializationDescription(
serializer.Kind,
SerializationFormat.Binary,
configurationTypeRepresentation);
var actualString = expected.ToDescribedSerializationUsingSpecificSerializer(stringDescription, serializer);
var actualBinary = expected.ToDescribedSerializationUsingSpecificSerializer(binaryDescription, serializer);
var actualFromString = actualString.DeserializePayloadUsingSpecificSerializer(serializer);
var actualFromBinary = actualBinary.DeserializePayloadUsingSpecificSerializer(serializer);
try
{
validationCallback(actualString, (T)actualFromString);
}
catch (Exception ex)
{
throw new NaosSerializationException(Invariant($"Failure confirming from string with {nameof(serializer)} - {serializer.GetType()} - {actualFromString}"), ex);
}
try
{
validationCallback(actualBinary, (T)actualFromBinary);
}
catch (Exception ex)
{
throw new NaosSerializationException(Invariant($"Failure confirming from binary with {nameof(serializer)} - {serializer.GetType()} - {actualFromBinary}"), ex);
}
}
}
