public void Should_be_able_to_serialize_and_deserialize_a_complex_type()
{
var complex = new ComplexSerializerType();
var serializer = new DefaultSerializer();
serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.SomeSerializerType));
serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.AnotherSerializerType));
serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.SomeSerializerType));
serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.AnotherSerializerType));
var stream = serializer.Serialize(complex);
var xml = new StreamReader(stream).ReadToEnd();
Assert.IsTrue(xml.Contains(complex.Id.ToString()));
stream.Position = 0;
Assert.AreEqual(complex.Id, ((ComplexSerializerType)serializer.Deserialize(typeof(ComplexSerializerType), stream)).Id);
Console.WriteLine(xml);
var some1 = new v1.SomeSerializerType();
var some2 = new v2.SomeSerializerType();
Assert.AreEqual(some1.Id, ((v1.SomeSerializerType)serializer.Deserialize(typeof(v1.SomeSerializerType), serializer.Serialize(some1))).Id);
Assert.AreEqual(some2.Id, ((v2.SomeSerializerType)serializer.Deserialize(typeof(v2.SomeSerializerType), serializer.Serialize(some2))).Id);
}
private async Task test <T>(DefaultSerializer serializer, MockResolveProxyIds resolver, params T[] values)
{
Assert.IsTrue(serializer.CanSerialize(typeof(T)));
foreach (var value in values)
{
var stream = new MemoryStream();
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, typeof(T), value, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size of {value}: {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, typeof(T), resolver, CancellationToken.None).ConfigureAwait(false);
Assert.AreEqual(value, deserializedValue);
}
}
}
public void Deserialize_ByteArray_WithICustomObjectCreator_CreatesCustomObjects()
{
// Arrange
var creator = new FakeCustomObjectCreator();
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var serializer = new DefaultSerializer(settings, settings)
{
DeserializationOptions = new DeserializationOptions()
{
CustomObjectCreator = creator
}
};
var jsonBuffer = Encoding.UTF8.GetBytes("{\"subNode\":{\"property\":\"value\"}}");
// Act
var result = serializer.Deserialize <JsonDocument>(jsonBuffer, 0, jsonBuffer.Length);
// Assert
Assert.NotNull(result);
Assert.NotNull(result.SubNode);
Assert.AreEqual(typeof(DocumentSubNodeInherited), result.SubNode.GetType());
Assert.AreEqual("value", result.SubNode.Property);
}
public async Task Test()
{
var resolver = new MockResolveProxyIds();
var serializer = new DefaultSerializer();
Assert.IsTrue(serializer.CanSerialize(typeof(DateTime)));
var values = new[]
{
DateTime.MinValue, DateTime.Today, DateTime.Now, DateTime.UtcNow, DateTime.MaxValue
};
foreach (var value in values)
{
var stream = new MemoryStream();
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, typeof(DateTime), value, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size of {value}: {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, typeof(DateTime), resolver, CancellationToken.None).ConfigureAwait(false);
Assert.AreEqual(value, deserializedValue);
}
}
}
public void Deserialize_Stream_WithICustomObjectCreator_CreatesCustomObjects()
{
// Arrange
var creator = new FakeCustomObjectCreator();
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var serializer = new DefaultSerializer(settings, settings)
{
DeserializationOptions = new DeserializationOptions()
{
CustomObjectCreator = creator
}
};
var stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"subNode\":{\"property\":\"value\"}}"));
// Act
var result = serializer.Deserialize<JsonDocument>(stream);
// Assert
Assert.NotNull(result);
Assert.NotNull(result.SubNode);
Assert.AreEqual(typeof(DocumentSubNodeInherited), result.SubNode.GetType());
Assert.AreEqual("value", result.SubNode.Property);
}
public void DeserializeNullInput()
{
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(null);
dict.Count.Should().Be(0);
}
public void DeserializeEmptyInput()
{
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(string.Empty);
dict.Count.Should().Be(0);
}
public void DeserializeDefault()
{
IStandardSerializer <User> serializer = new DefaultSerializer <User>();
User user = serializer.Deserialize("Test test");
Assert.AreEqual("Test", user.Name);
Assert.AreEqual("test", user.Firstname);
}
public void TagHelper_Deserialization()
{
// Deserialize from json file.
IReadOnlyList <TagHelperDescriptor> tagHelpers;
using var stream = new MemoryStream(_tagHelperBuffer);
using var reader = new JsonTextReader(new StreamReader(stream));
tagHelpers = DefaultSerializer.Deserialize <IReadOnlyList <TagHelperDescriptor> >(reader);
}
public async Task <IEnumerable <QueuedMessage> > Dequeue(int count) =>
(await DbSet
.Where(m => m.Produced == null)
.OrderBy(m => m.Id)
.Take(count)
.ToListAsync())
.Select(message => new DbQueuedMessage(
message.Id,
DefaultSerializer.Deserialize <IOutboundMessage>(message.Message)));
public async Task <IEnumerable <QueuedMessage> > Dequeue(int count) =>
(await DbSet.AsQueryable()
.Where(m => m.Produced == null)
.OrderBy(m => m.Id)
.Take(count)
.ToListAsync())
.Select(message => new DbQueuedMessage(
message.Id,
message.Content,
DefaultSerializer.Deserialize <IEnumerable <MessageHeader> >(message.Headers),
DefaultSerializer.Deserialize <IEndpoint>(message.Endpoint)));
public static IConfiguration From(string xml, Encoding encoding)
{
Guard.AgainstNullOrEmptyString(xml, nameof(xml));
Guard.AgainstNull(encoding, nameof(encoding));
var serializer = new DefaultSerializer();
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
{
return((IConfiguration)serializer.Deserialize(typeof(DefaultConfiguration), stream));
}
}
public void BinarySerialization()
{
var reg = new MessageRegistry();
var ser = new DefaultSerializer<SubMessage>(reg, new TypeRegistry( new[] { TypeRegistry.StandartTypes, new[] { new VectorXYZBinarySerializer() }}));
using (var buf = new ThreadSafeWriteQueue(1024))
{
var src = new SubMessage { Vector3 = new Vector3(1.1f, 2.2f, 3.3f) };
ser.Serialize(buf, src);
var dst = new SubMessage();
ser.Deserialize(buf, buf.ReadMessage(), dst);
Assert.AreEqual(src.Vector3, dst.Vector3);
}
}
public void DeserializeDictionaries()
{
var json = @"
{
""foo"": ""bar"",
""baz"": 123
}";
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(json);
dict["foo"].Should().Be("bar");
dict["baz"].Should().Be(123L);
}
public void Should_be_able_to_serialize_and_deserialize_a_simple_type()
{
var original = new SimpleSerializerType();
var serializer = new DefaultSerializer();
var stream = serializer.Serialize(original);
var xml = new StreamReader(stream).ReadToEnd();
Assert.IsTrue(xml.Contains(original.Id.ToString()));
stream.Position = 0;
Assert.AreEqual(original.Id, ((SimpleSerializerType)serializer.Deserialize(typeof(SimpleSerializerType), stream)).Id);
}
public void DeserializeDateAsString()
{
var date = DateTimeOffset.UtcNow;
var json = $@"
{{
""foo"": ""{date}"",
}}";
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(json);
dict["foo"].Should().Be(date.ToString());
dict["foo"].GetType().Should().Be(typeof(string));
}
public void EmptyString()
{
var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SubMessage { Text = string.Empty, };
r.Serialize(buf, orig);
SubMessage message = new SubMessage();
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.IsTrue(string.IsNullOrEmpty(message.Text));
}
}
public void TestVec4()
{
var r = new DefaultSerializer<SingleMessage<Vector4>>(this.messageRegistry, this.typeRegistry,4);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SingleMessage<Vector4> { MessageId = r.MessageId, A = new Vector4(1.1f, 2.2f, 3.3f,( 4.4f)) };
r.Serialize(buf, orig);
SingleMessage<Vector4> message = new SingleMessage<Vector4>();
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.AreEqual(orig.A, message.A);
}
}
/// <summary>
/// Deserialize an object from a file in the working folder.
///
/// <para>
/// Rethrows any exceptions that occur during deserialization.
/// </para>
///
/// </summary>
/// <typeparam name="T">Type of the object being deserialized.</typeparam>
/// <param name="filename">Name of the file holding the serialized object.</param>
/// <returns>An object reconstructed from the data in the file.</returns>
public T Deserialize <T>(string filename)
{
using (StreamReader sr = new StreamReader(GetPath(filename)))
using (JsonReader reader = new JsonTextReader(sr))
{
try
{
return(DefaultSerializer.Deserialize <T>(reader));
}
catch (JsonException e)
{
// Hide JSON implementation details.
throw new Exception(e.Message);
}
}
}
public void DeserializeNestedDictionaries()
{
var json = @"
{
""foo"": ""bar"",
""baz"": {
""qux"": 123
}
}";
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(json);
dict["foo"].Should().Be("bar");
dict["baz"].Should().BeAssignableTo <IReadOnlyDictionary <string, object> >();
(dict["baz"] as IReadOnlyDictionary <string, object>)["qux"].Should().Be(123L);
}
public void DeserializeArraysAsLists()
{
var json = @"
{
""things"": [
""foo"", ""bar"", ""baz""
]
}";
var serializer = new DefaultSerializer();
var dict = serializer.Deserialize(json);
dict["things"].Should().NotBeNull();
var things = dict["things"] as IList <object>;
things.OfType <string>().Should().BeEquivalentTo("foo", "bar", "baz");
}
public async Task Test()
{
var resolver = new MockResolveProxyIds();
var serializer = new DefaultSerializer();
var stream = new MemoryStream();
var str = new string(new[]
{
char.MinValue,
//standard ASCII
'A',
'Z',
'a',
'z',
//extended ASCII
'À',
'Ï',
//unicode
'Ā',
'ď',
char.MaxValue
});
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, typeof(string), str, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size of \"{str}\": {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, typeof(string), resolver, CancellationToken.None).ConfigureAwait(false);
Assert.AreEqual(deserializedValue, str);
}
}
public void TagHelper_Serialization_RoundTrip()
{
// Serialize back to json.
MemoryStream originalStream;
using (originalStream = new MemoryStream())
using (var writer = new StreamWriter(originalStream, Encoding.UTF8, bufferSize: 4096))
{
DefaultSerializer.Serialize(writer, DefaultTagHelpers);
}
IReadOnlyList <TagHelperDescriptor> reDeserializedTagHelpers;
var stream = new MemoryStream(originalStream.GetBuffer());
using (stream)
using (var reader = new JsonTextReader(new StreamReader(stream)))
{
reDeserializedTagHelpers = DefaultSerializer.Deserialize <IReadOnlyList <TagHelperDescriptor> >(reader);
}
}
public override IDisposable Subscribe(IObserver <IMessage <string, T> > observer)
{
RegisterOnCompleted(observer);
return(this.Connection.On <string, string>(EventName, (meta, data) =>
{
try
{
T metaData = DefaultSerializer.Deserialize <T>(meta);
IMessage <string, T> message = new StringMessage <T>(data, metaData);
observer.OnNext(message);
}
catch (Exception ex)
{
observer.OnError(ex);
}
}));
}
private async Task test(DefaultSerializer serializer, MockResolveProxyIds resolver, object value)
{
var stream = new MemoryStream();
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, typeof(object), value, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size of {value}: {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, typeof(object), resolver, CancellationToken.None).ConfigureAwait(false);
Assert.AreEqual(deserializedValue, value);
}
}
private async Task test(DefaultSerializer serializer, MockResolveProxyIds resolver, Array value)
{
var arrayType = value.GetType();
Assert.IsTrue(serializer.CanSerialize(arrayType));
var stream = new MemoryStream();
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, arrayType, value, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size of {value}: {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, arrayType, resolver, CancellationToken.None).ConfigureAwait(false) as Array;
Assert.IsNotNull(deserializedValue);
Assert.AreEqual(value.Rank, deserializedValue.Rank, "Ranks don't match.");
for (var dimension = 0; dimension < value.Rank; dimension++)
{
Assert.AreEqual(value.GetLength(dimension), deserializedValue.GetLength(dimension), $"Lengths ({dimension}) don't match.");
Assert.AreEqual(value.GetLowerBound(dimension), deserializedValue.GetLowerBound(dimension), $"Lower bounds ({dimension}) don't match.");
Assert.AreEqual(value.GetUpperBound(dimension), deserializedValue.GetUpperBound(dimension), $"Upper bounds ({dimension}) don't match.");
}
var enumerator = value.GetEnumerator();
var deserializedEnumerator = deserializedValue.GetEnumerator();
while (enumerator.MoveNext())
{
Assert.IsTrue(deserializedEnumerator.MoveNext());
Assert.AreEqual(enumerator.Current, deserializedEnumerator.Current);
}
Assert.IsFalse(deserializedEnumerator.MoveNext());
}
}
public async Task Test()
{
var resolver = new MockResolveProxyIds();
var serializer = new DefaultSerializer();
var stream = new MemoryStream();
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
await serializer.Serialize(writer, typeof(object), null, resolver).ConfigureAwait(false);
}
Console.WriteLine($"Size: {stream.Length}");
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var deserializedValue = await serializer.Deserialize(reader, typeof(object), resolver, CancellationToken.None).ConfigureAwait(false);
Assert.IsNull(deserializedValue);
}
}
public void DeserializeThrowsArgumentNullException()
{
var ex = Assert.Throws <ArgumentNullException>(() => m_serializer.Deserialize <MimeEntity>((byte[])null));
Assert.Equal("messageBytes", ex.ParamName);
}
public void DeserializeToObject()
{
var result = serializer.Deserialize(
serializer.Serialize(new object()), typeof(object)
).ShouldBeOfType <object>();
}
public void ThreeBytesString()
{
var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SubMessage { Text = "aaa", };
r.Serialize(buf, orig);
r.Serialize(buf, orig);
SubMessage message = new SubMessage();
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.AreEqual(orig.Text, message.Text);
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.AreEqual(orig.Text, message.Text);
}
}
public void TwoMessages()
{
var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SubMessage
{ MessageId = int.MaxValue, A = int.MinValue, B = float.Epsilon, C = uint.MinValue, Byte = 1, Text = "aaaвпаав", };
var orig2 = new SubMessage
{
MessageId = int.MaxValue,
A = int.MaxValue,
B = float.MaxValue,
C = uint.MaxValue,
Byte = 255,
Text = "впаавzz",
};
r.Serialize(buf, orig);
r.Serialize(buf, orig2);
SubMessage message = new SubMessage();
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.AreEqual(orig.A, message.A);
Assert.AreEqual(orig.B, message.B);
Assert.AreEqual(orig.C, message.C);
Assert.AreEqual(orig.Text, message.Text);
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig2.MessageId, message.MessageId);
Assert.AreEqual(orig2.A, message.A);
Assert.AreEqual(orig2.B, message.B);
Assert.AreEqual(orig2.C, message.C);
Assert.AreEqual(orig2.Text, message.Text);
}
}
private async Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
{
if (!eventArgs.ApplicationMessage.Topic.Contains(GetRequestTopic(null, null)))
{
return;
}
var message = eventArgs.ApplicationMessage;
var methodName = message.GetUserProperty("Method");
var id = message.GetUserProperty("Id");
var timeout = message.GetUserProperty <int?>("Timeout");
var broadcast = message.GetUserProperty <bool?>("Broadcast") ?? false;
var noResponse = message.GetUserProperty <bool?>("NoResponse") ?? false;
var clientId = GetSource(message.Topic);
using var serviceScope = _serviceProvider.CreateScope();
using var cts = timeout.HasValue ? new CancellationTokenSource(timeout.Value * 1000) : new CancellationTokenSource();
var responseBuilder = new MqttApplicationMessageBuilder()
.WithContentType(DefaultSerializer.ContentType)
.WithTopic(GetResponseTopic(GetSource(message.Topic)))
.WithAtLeastOnceQoS();
if (broadcast)
{
responseBuilder.WithUserProperty("Broadcast", true.ToString());
}
if (timeout > 0)
{
responseBuilder.WithMessageExpiryInterval((uint)timeout.Value);
}
try
{
if (!RpcMethodResolver.Methods.TryGetValue(methodName, out var method))
{
if (string.IsNullOrEmpty(id) || noResponse)
{
return;
}
throw new EntryPointNotFoundException($"Method '{methodName}' not found.");
}
var parameters = method.GetParameters();
object[] args;
switch (parameters.Length)
{
case 0:
args = null;
break;
case 1:
var parameterInfo = parameters.First();
args = parameterInfo.ParameterType == typeof(byte[])
? new[] { (object)message.Payload }
: new[] { DefaultSerializer.Deserialize(message.Payload, parameterInfo.ParameterType) };
break;
default:
_logger.Error(new NotImplementedException(), "Multiple parameters resolving has not been supported yet, please use a key-value object.");
return;
}
var rpcService = (IRpcService)serviceScope.ServiceProvider.GetService(method.DeclaringType);
rpcService.CurrentContext = new RpcContext
{
Topic = message.Topic,
RemoteClientId = clientId
};
var task = Task.Run(async() =>
{
var returnValue = method.Invoke(rpcService, args);
if (returnValue is Task t)
{
await t.ConfigureAwait(false);
if (t.GetType().IsGenericType)
{
var resultProperty = t.GetType().GetProperty("Result");
Debug.Assert(resultProperty != null);
returnValue = resultProperty.GetValue(t);
}
}
return(returnValue);
}, cts.Token);
if (!string.IsNullOrEmpty(id))
{
if (!_waitingCalls.TryAdd(id, new CancellableTask(task, cts)))
{
throw new InvalidOperationException();
}
}
else
{
_noIdCalls.TryAdd(cts, task);
}
var result = await task.ConfigureAwait(false);
responseBuilder.WithUserProperty("Success", true.ToString());
if (!noResponse)
{
responseBuilder.WithUserProperty("Id", id)
.WithPayload(DefaultSerializer.Serialize(result));
}
}
catch (Exception ex)
{
responseBuilder.WithUserProperty("Success", false.ToString())
.WithUserProperty("ErrorCode", ex.HResult.ToString())
.WithUserProperty("ErrorMessage", ex.Message);
}
finally
{
if (!string.IsNullOrEmpty(id))
{
_waitingCalls.TryRemove(id, out _);
}
else
{
_noIdCalls.TryRemove(cts, out _);
}
if (!noResponse)
{
await _mqttClient.PublishAsync(responseBuilder.Build()).ConfigureAwait(false);
}
}
}
public void GetErrorMessageFromFormValidationError()
{
#region response objects
var responseWithErrorMessage = @"{
""remediation"": {
""type"": ""array"",
""value"": [
{
""rel"": [
""create-form""
],
""name"": ""reset-authenticator"",
""relatesTo"": [
""$.currentAuthenticator""
],
""href"": "".................."",
""method"": ""POST"",
""produces"": ""application/ion+json; okta-version=1.0.0"",
""value"": [
{
""name"": ""credentials"",
""type"": ""object"",
""form"": {
""value"": [
{
""name"": ""passcode"",
""label"": ""New password"",
""secret"": true,
""messages"": {
""type"": ""array"",
""value"": [
{
""message"": ""Error Message"",
""i18n"": {
""key"": ""password.passwordRequirementsNotMet"",
""params"": [
""Password requirements: at least 8 characters,""
]
},
""class"": ""ERROR""
}
]
}
}
]
},
""required"": true
}
],
""accepts"": ""application/json; okta-version=1.0.0""
}
]
}
}";
var responseWithNoErrors = @"{
""remediation"": {
""type"": ""array"",
""value"": [
{
""rel"": [
""create-form""
],
""name"": ""reset-authenticator"",
""relatesTo"": [
""$.currentAuthenticator""
],
""value"": [
{
""form"": {
""value"": [
{
""name"": ""passcode"",
""label"": ""New password"",
""secret"": true,
}
]
},
""required"": true
}
],
""accepts"": ""application/json; okta-version=1.0.0""
}
]
}
}";
#endregion response objects
var serializer = new DefaultSerializer();
var resourseFactory = new ResourceFactory(null, null, null);
var errorData = serializer.Deserialize(responseWithErrorMessage);
var errorObject = resourseFactory.CreateNew <IonApiError>(errorData);
errorObject.ErrorSummary.Should().Be("Error Message");
errorData = serializer.Deserialize(responseWithNoErrors);
errorObject = resourseFactory.CreateNew <IonApiError>(errorData);
errorObject.ErrorSummary.Should().BeNullOrEmpty();
errorData = serializer.Deserialize("{ }");
errorObject = resourseFactory.CreateNew <IonApiError>(errorData);
errorObject.ErrorSummary.Should().BeNullOrEmpty();
}
