public static void NaosJsonSerializer___With_type_Compact___Uses_compact()
{
// Arrange
var property1 = A.Dummy <string>();
var property2 = A.Dummy <string>();
var property3 = A.Dummy <string>();
var expected = "{"
+ Invariant($"\"property1\":\"{property1}\",")
+ Invariant($"\"property2\":\"{property2}\",")
+ Invariant($"\"property3\":\"{property3}\",")
+ "\"property4\":null"
+ "}";
var test = new TestObject {
Property1 = property1, Property2 = property2, Property3 = property3,
};
var serializer = new NaosJsonSerializer(unregisteredTypeEncounteredStrategy: UnregisteredTypeEncounteredStrategy.Attempt, formattingKind: JsonFormattingKind.Compact);
// Act
var actual = serializer.SerializeToString(test);
// Assert
actual.Should().Be(expected);
}
public static void NaosJsonSerializer___With_type_Default___Uses_default()
{
// Arrange
var property1 = A.Dummy <string>();
var property2 = A.Dummy <string>();
var property3 = A.Dummy <string>();
var expected = "{"
+ Environment.NewLine
+ Invariant($" \"property1\": \"{property1}\",") + Environment.NewLine
+ Invariant($" \"property2\": \"{property2}\",") + Environment.NewLine
+ Invariant($" \"property3\": \"{property3}\",") + Environment.NewLine
+ " \"property4\": null" + Environment.NewLine
+ "}";
var test = new TestObject {
Property1 = property1, Property2 = property2, Property3 = property3,
};
var serializer = new NaosJsonSerializer(unregisteredTypeEncounteredStrategy: UnregisteredTypeEncounteredStrategy.Attempt);
// Act
var actual = serializer.SerializeToString(test);
// Assert
actual.Should().Be(expected);
}
public static void Presence_of_concreteType_token_does_not_interfere_with_normal_deserialization()
{
// Arrange
var expectedId = "year-field";
var expectedDecimalPlaces = 5;
var expectedTitle = "my-title";
var year = new YearField(expectedId)
{
NumberOfDecimalPlaces = expectedDecimalPlaces,
Title = expectedTitle,
};
var serializer = new NaosJsonSerializer(typeof(GenericDiscoveryJsonConfiguration <Field>));
var jsonWithConcreteType = serializer.SerializeToString(year);
var settings = new NullJsonConfiguration().BuildJsonSerializerSettings(SerializationDirection.Deserialize);
settings.Converters = new JsonConverter[0];
// Act
var actual = JsonConvert.DeserializeObject <YearField>(jsonWithConcreteType, settings);
// Assert
typeof(YearField).IsAssignableTo(typeof(Field)).Should().BeTrue();
jsonWithConcreteType.Should().Contain("$concreteType");
actual.Id.Should().Be(expectedId);
actual.NumberOfDecimalPlaces.Should().Be(expectedDecimalPlaces);
actual.Title.Should().Be(expectedTitle);
}
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 TestBase()
{
var serializer = new NaosJsonSerializer(typeof(GenericDiscoveryJsonConfiguration <TestBase>));
var tasks = Enumerable.Range(1, 100).Select(_ => A.Dummy <TestBase>())
.Select(_ => new Task(() => serializer.SerializeToString(_))).ToArray();
Parallel.ForEach(tasks, _ => _.Start());
Task.WaitAll(tasks);
}
public static void RootFirstWorks()
{
var middleSerializer = new NaosJsonSerializer(typeof(ConfigMiddle));
middleSerializer.SerializeToString(null);
var topSerializer = new NaosJsonSerializer(typeof(ConfigTop));
topSerializer.SerializeToString(null);
}
public static void JsonCanSerializeNull()
{
// Arrange
var serializer = new NaosJsonSerializer();
// Act
var actualNullString = serializer.SerializeToString(null);
var actualNullBytes = serializer.SerializeToBytes(null);
var actualString = serializer.SerializeToString(SerializationConfigurationBase.NullSerializedStringValue);
var actualNullFromString = serializer.Deserialize <NullableObject>(actualNullString);
var actualNullFromBytes = serializer.Deserialize <NullableObject>(actualNullBytes);
var actual = serializer.Deserialize <string>(actualString);
// Assert
actualNullString.Should().Be(SerializationConfigurationBase.NullSerializedStringValue);
actualNullFromString.Should().BeNull();
actualNullFromBytes.Should().BeNull();
actualString.Should().NotBe(SerializationConfigurationBase.NullSerializedStringValue);
actual.Should().Be(SerializationConfigurationBase.NullSerializedStringValue);
}
public static void JsonSerializeStringToString()
{
// Arrange
var jsonSerializer = new NaosJsonSerializer <GenericDiscoveryJsonConfiguration <string> >();
var input = A.Dummy <string>();
// Act
var actualJsonString = jsonSerializer.SerializeToString(input);
var actualJsonFromString = jsonSerializer.Deserialize <string>(actualJsonString);
// Assert
actualJsonFromString.Should().Be(input);
}
public static void Serialize___Not_date_time___Throws()
{
// Arrange
var serializer = new NaosJsonSerializer();
Action action = () => serializer.SerializeToString("not a datetime");
// Act
var exception = Record.Exception(action);
// Assert
exception.Should().NotBeNull();
exception.Should().BeOfType <ArgumentException>();
exception.Message.Should().Be("Parameter 'typeMustBeDateTimeOrNullableDateTime-System.String' is not true. Parameter value is 'False'.");
}
public static void RoundtripSerializeDeserialize___Using_local_negative_offset___Works()
{
// Arrange
var expected = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"));
var serializer = new NaosJsonSerializer();
// Act
var serialized = serializer.SerializeToString(expected);
var actual = serializer.Deserialize <DateTime>(serialized);
// Assert
actual.Kind.Should().Be(expected.Kind);
actual.Should().Be(expected);
}
public static void RoundtripSerializeDeserialize___Using_unspecified___Works()
{
// Arrange
var expected = DateTime.UtcNow.ToUnspecified();
var serializer = new NaosJsonSerializer();
// Act
var serialized = serializer.SerializeToString(expected);
var actual = serializer.Deserialize <DateTime>(serialized);
// Assert
actual.Kind.Should().Be(expected.Kind);
actual.Should().Be(expected);
}
public static void Deserialize___Should_return_object_of_type_CalendarYearAccountingPeriodSystem___When_an_object_of_that_type_is_serialized_to_json_and_deserialized_as_AccountingPeriodSystem()
{
// Arrange
var serializer = new NaosJsonSerializer();
var originalAccountingPeriodSystem = new CalendarYearAccountingPeriodSystem();
var serializedJsonBytes = serializer.SerializeToBytes(originalAccountingPeriodSystem);
var serializedJsonString = serializer.SerializeToString(originalAccountingPeriodSystem);
// Act
var systemUnderTest1 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonBytes);
var systemUnderTest2 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonString);
// Assert
systemUnderTest1.Should().BeOfType <CalendarYearAccountingPeriodSystem>();
systemUnderTest2.Should().BeOfType <CalendarYearAccountingPeriodSystem>();
}
public static void Deserialize___Should_return_equivalent_object_of_type_FiscalYearAccountingPeriodSystem___When_an_object_of_that_type_is_serialized_to_json_and_deserialized_as_AccountingPeriodSystem()
{
// Arrange
var serializer = new NaosJsonSerializer();
var expectedAccountingPeriodSystem = new FiscalYearAccountingPeriodSystem(A.Dummy <MonthOfYear>().ThatIsNot(MonthOfYear.December));
var serializedJsonBytes = serializer.SerializeToBytes(expectedAccountingPeriodSystem);
var serializedJsonString = serializer.SerializeToString(expectedAccountingPeriodSystem);
// Act
var systemUnderTest1 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonBytes) as FiscalYearAccountingPeriodSystem;
var systemUnderTest2 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonString) as FiscalYearAccountingPeriodSystem;
// Assert
systemUnderTest1.Should().NotBeNull();
systemUnderTest1.LastMonthInFiscalYear.Should().Be(expectedAccountingPeriodSystem.LastMonthInFiscalYear);
systemUnderTest2.Should().NotBeNull();
systemUnderTest2.LastMonthInFiscalYear.Should().Be(expectedAccountingPeriodSystem.LastMonthInFiscalYear);
}
public static void Deserialize___Should_return_equivalent_object_of_type_FiftyTwoFiftyThreeWeekAccountingPeriodSystem___When_an_object_of_that_type_is_serialized_to_json_and_deserialized_as_AccountingPeriodSystem()
{
// Arrange
var serializer = new NaosJsonSerializer();
var expectedAccountingPeriodSystem = A.Dummy <FiftyTwoFiftyThreeWeekAccountingPeriodSystem>();
var serializedJsonBytes = serializer.SerializeToBytes(expectedAccountingPeriodSystem);
var serializedJsonString = serializer.SerializeToString(expectedAccountingPeriodSystem);
// Act
var systemUnderTest1 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonBytes) as FiftyTwoFiftyThreeWeekAccountingPeriodSystem;
var systemUnderTest2 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonString) as FiftyTwoFiftyThreeWeekAccountingPeriodSystem;
// Assert
systemUnderTest1.Should().NotBeNull();
systemUnderTest1.AnchorMonth.Should().Be(expectedAccountingPeriodSystem.AnchorMonth);
systemUnderTest1.FiftyTwoFiftyThreeWeekMethodology.Should().Be(expectedAccountingPeriodSystem.FiftyTwoFiftyThreeWeekMethodology);
systemUnderTest1.LastDayOfWeekInAccountingYear.Should().Be(expectedAccountingPeriodSystem.LastDayOfWeekInAccountingYear);
systemUnderTest2.Should().NotBeNull();
systemUnderTest2.AnchorMonth.Should().Be(expectedAccountingPeriodSystem.AnchorMonth);
systemUnderTest2.FiftyTwoFiftyThreeWeekMethodology.Should().Be(expectedAccountingPeriodSystem.FiftyTwoFiftyThreeWeekMethodology);
systemUnderTest2.LastDayOfWeekInAccountingYear.Should().Be(expectedAccountingPeriodSystem.LastDayOfWeekInAccountingYear);
}
public static void LambdaSerializer__Passes_through()
{
// Arrange
var property1 = A.Dummy <string>();
var property2 = A.Dummy <string>();
var property3 = A.Dummy <string>();
var expected = "{"
+ Environment.NewLine
+ Invariant($" \"property1\": \"{property1}\",") + Environment.NewLine
+ Invariant($" \"property2\": \"{property2}\",") + Environment.NewLine
+ Invariant($" \"property3\": \"{property3}\",") + Environment.NewLine
+ " \"property4\": null" + Environment.NewLine
+ "}";
var test = new TestObjectForLambda {
Property1 = property1, Property2 = property2, Property3 = property3,
};
var backingSerializer = new NaosJsonSerializer(unregisteredTypeEncounteredStrategy: UnregisteredTypeEncounteredStrategy.Attempt);
var serializer = new NaosLambdaBackedSerializer(
backingSerializer.SerializeToString,
backingSerializer.Deserialize,
backingSerializer.SerializeToBytes,
backingSerializer.Deserialize);
// Act
var stringOut = serializer.SerializeToString(test);
var stringRoundTrip = serializer.Deserialize(stringOut, test.GetType());
var bytesOut = serializer.SerializeToBytes(stringRoundTrip);
var bytesRoundTrip = serializer.Deserialize(bytesOut, stringRoundTrip.GetType());
var actual = backingSerializer.SerializeToString(bytesRoundTrip);
// Assert
actual.Should().Be(expected);
stringOut.Should().Be(expected);
}
