public static void Deserializing_constructors___When_properties_do_not_exist___Throws()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
var input = new ConstructorWithoutProperties(A.Dummy <string>(), A.Dummy <string>());
// Act
var serializedString = serializer.SerializeToString(input);
var exception = Record.Exception(() => serializer.Deserialize <ConstructorWithProperties>(serializedString));
// Act
exception.Should().NotBeNull();
exception.Message.Should().Be("Could not find a parameterless constructor or a constructor whose parameter names matched the properties provided; type: Naos.Serialization.Test.NaosPropertyBagSerializerTest+ConstructorWithoutProperties, properties: Property,ToString,GetType.");
}
public static void Deserializing_constructors___When_properties_exist___Works()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
var input = new ConstructorWithProperties(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>());
// Act
var serializedString = serializer.SerializeToString(input);
var actual = serializer.Deserialize <ConstructorWithProperties>(serializedString);
// Act
actual.PropertyGetOnly.Should().Be(input.PropertyGetOnly);
actual.PropertyPrivateSet.Should().Be(input.PropertyPrivateSet);
actual.PropertyPublicSet.Should().Be(input.PropertyPublicSet);
}
public static void Configuration___Specifying_type___Works()
{
// Arrange
var configurationType = typeof(PropertyBagConfig);
var serializer = new NaosPropertyBagSerializer(configurationType, UnregisteredTypeEncounteredStrategy.Attempt);
var input = new StringProperty {
StringItem = A.Dummy <string>()
};
// Act
var serializedString = serializer.SerializeToString(input);
var actual = serializer.Deserialize <StringProperty>(serializedString);
// Act
actual.StringItem.Should().Be(CustomStringSerializer.CustomReplacementString);
}
public static void Deserializing_collections___When_serialized_string_has_a_comma___Works()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
var input = new HasSerializesWithComma {
WithCommas = new[] { new SerializesWithComma(), new SerializesWithComma() }.ToList()
};
// Act
var serializedString = serializer.SerializeToString(input);
var actual = serializer.Deserialize <HasSerializesWithComma>(serializedString);
// Act
actual.WithCommas.Count.Should().Be(input.WithCommas.Count);
actual.WithCommas.ToList().ForEach(_ => _.Should().NotBeNull());
}
public static void PropertyBagCanSerializeNull()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
// 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>();
actualStringException.Message.Should().Be("String is not supported as a type for this serializer.");
}
public static void RoundTrip___Supported_scenarios___Works()
{
// Arrange
var serializer = new NaosPropertyBagSerializer();
var input = new ComplicatedObject
{
NullableDecimal = 29m,
BaseVersion = new InheritTypeDerive(),
DeriveVersion = new InheritTypeDerive(),
DeriveVersionArray = new[] { new InheritTypeDerive(), },
DeriveVersionCollection = new[] { new InheritTypeDerive(), }.ToList(),
String = A.Dummy <string>(),
Int = A.Dummy <int>(),
TimeSpan = A.Dummy <TimeSpan>(),
DateTime = A.Dummy <DateTime>(),
DateTimeNullable = A.Dummy <DateTime>(),
StringAttributed = A.Dummy <string>(),
CustomWithAttribute = new CustomWithAttribute(),
CustomWithoutInterface = new CustomWithoutInterface(),
CustomWithInterface = new CustomWithInterface(),
StringArray = new[] { A.Dummy <string>(), },
StringCollection = new[] { A.Dummy <string>(), }.ToList(),
IntCollection = new[] { A.Dummy <int>(), }.ToList(),
TimeSpanCollection = new[] { A.Dummy <TimeSpan>(), }.ToList(),
DateTimeCollection = new[] { A.Dummy <DateTime>(), }.ToList(),
CustomWithoutInterfaceCollection = new[] { new CustomWithoutInterface(), new CustomWithoutInterface(), }.ToList(),
CustomWithInterfaceCollection = new[] { new CustomWithInterface(), new CustomWithInterface(), }.ToList(),
CustomElementArray = new[] { new CustomElement(), new CustomElement(), },
CustomElementCollection = new[] { new CustomElement(), new CustomElement(), }.ToList(),
EnumParseCollection = new[] { EnumParse.Default, EnumParse.Value, },
EnumAttributeCollection = new[] { EnumAttribute.Default, EnumAttribute.Value, },
EnumAttributePropertyCollection = new[] { EnumAttributeProperty.Default, EnumAttributeProperty.Value, },
EnumParse = EnumParse.Value,
EnumAttribute = EnumAttribute.Value,
EnumAttributeProperty = EnumAttributeProperty.Value,
StringCollectionWithSingleEmptyString = new[] { string.Empty },
StringCollectionWithNulls = new[] { string.Empty, A.Dummy <string>(), null, string.Empty, null, A.Dummy <string>() },
};
// Act
var serializedPropertyBag = serializer.SerializeToPropertyBag(input);
var serializedString = serializer.SerializeToString(input);
var serializedBytes = serializer.SerializeToBytes(input);
var actualPropertyBag = serializer.Deserialize <ComplicatedObject>(serializedPropertyBag);
var actualString = serializer.Deserialize <ComplicatedObject>(serializedString);
var actualBytes = serializer.Deserialize <ComplicatedObject>(serializedBytes);
// Assert
void AssertCorrect(ComplicatedObject actual)
{
actual.NullableDecimal.Should().Be(input.NullableDecimal);
actual.NullableDecimalDefault.Should().BeNull();
actual.BaseVersion.Should().NotBeNull();
actual.DeriveVersion.Should().NotBeNull();
actual.DeriveVersionArray.Count().Should().Be(input.DeriveVersionArray.Count());
actual.DeriveVersionCollection.Count().Should().Be(input.DeriveVersionCollection.Count());
actual.String.Should().Be(input.String);
actual.Int.Should().Be(input.Int);
actual.TimeSpan.Should().Be(input.TimeSpan);
actual.DateTime.Should().Be(input.DateTime);
actual.DateTimeNullable.Should().Be(input.DateTimeNullable);
actual.StringAttributed.Should().Be(CustomStringSerializer.CustomReplacementString);
actual.CustomWithAttribute.Should().NotBeNull();
actual.CustomWithoutInterface.Should().NotBeNull();
actual.CustomWithInterface.Should().NotBeNull();
actual.StringDefault.Should().BeNull();
actual.IntDefault.Should().Be(default(int));
actual.TimeSpanDefault.Should().Be(default(TimeSpan));
actual.DateTimeDefault.Should().Be(default(DateTime));
actual.DateTimeNullableDefault.Should().BeNull();
actual.CustomWithoutInterfaceDefault.Should().BeNull();
actual.CustomWithInterfaceDefault.Should().BeNull();
actual.StringArray.Should().Equal(input.StringArray);
actual.StringCollection.Should().Equal(input.StringCollection);
actual.IntCollection.Should().Equal(input.IntCollection);
actual.TimeSpanCollection.Should().Equal(input.TimeSpanCollection);
actual.DateTimeCollection.Should().Equal(input.DateTimeCollection);
actual.CustomWithoutInterfaceCollection.Should().HaveCount(input.CustomWithoutInterfaceCollection.Count());
actual.CustomWithInterfaceCollection.Should().HaveCount(input.CustomWithInterfaceCollection.Count());
actual.CustomElementArray.Length.Should().Be(input.CustomElementArray.Length);
actual.CustomElementArray.Any(_ => _ == null).Should().BeFalse();
actual.CustomElementCollection.Count().Should().Be(input.CustomElementCollection.Count());
actual.CustomElementCollection.Any(_ => _ == null).Should().BeFalse();
actual.EnumParseCollection.Should().Equal(input.EnumParseCollection);
actual.EnumAttributeCollection.Should().BeEquivalentTo(Enumerable.Range(0, input.EnumAttributeCollection.Count).Select(_ => EnumAttributeProperty.Replaced));
actual.EnumAttributePropertyCollection.Should().BeEquivalentTo(Enumerable.Range(0, input.EnumAttributePropertyCollection.Count).Select(_ => EnumAttributeProperty.Replaced));
actual.EnumDefault.Should().Be(EnumParse.Default);
actual.EnumParse.Should().Be(input.EnumParse);
actual.EnumAttribute.Should().Be(EnumAttribute.Replaced);
actual.EnumAttributeProperty.Should().Be(EnumAttributeProperty.Replaced);
actual.StringCollectionDefault.Should().BeNull();
actual.StringCollectionWithSingleEmptyString.Should().Equal(input.StringCollectionWithSingleEmptyString);
actual.StringCollectionWithNulls.Should().Equal(input.StringCollectionWithNulls);
}
AssertCorrect(actualPropertyBag);
AssertCorrect(actualString);
AssertCorrect(actualBytes);
}
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);
}
}
}
