public void CorrectlyHandlesDeserializationWhenAlternativeEncodingIsUsed(string encodingWebName)
{
// arrange
var encoding = Encoding.GetEncoding(encodingWebName);
var bytes = encoding.GetBytes(SerializedMessage);
Console.WriteLine(@"This is how it looks as ASCII:
{0}", Encoding.ASCII.GetString(bytes));
var receivedTransportMessage =
new ReceivedTransportMessage
{
Headers = new Dictionary <string, object>
{
{ Headers.ContentType, "text/json" },
{ Headers.Encoding, encodingWebName },
},
Body = bytes,
};
// act
var deserializedMessage = serializer.Deserialize(receivedTransportMessage);
// assert
deserializedMessage.Messages.Length.ShouldBe(1);
var message = deserializedMessage.Messages.Single();
message.ShouldBeOfType <SomeComplexObjectThatRequïresÜnicódeToWørk>();
((SomeComplexObjectThatRequïresÜnicódeToWørk)message).ThisIsÜnicøde.ShouldBe("thiß ís jüst tæxt");
}
public void can_deserialize_from_either_fully_or_partially_qualified_names()
{
//n.b. the previous version of the JsonMessageSerializer was fully qualified, and
//this test demonstrates cross compability with that version
var obj1 = new TestObject {
Data1 = Guid.NewGuid().ToString("N")
};
var obj2 = new TestObject {
Data1 = Guid.NewGuid().ToString("N")
};
var fullyQualifiedSerializer = new JsonMessageSerializer {
FullyQualify = true
};
var partiallyQualifiedSerializer = new JsonMessageSerializer();
//serialize with and without fully qualified names
var eventData1 = fullyQualifiedSerializer.Serialize(obj1);
var eventData2 = partiallyQualifiedSerializer.Serialize(obj2);
//switch serializers
var deserialized1 = partiallyQualifiedSerializer.Deserialize(eventData1);
var deserialized2 = partiallyQualifiedSerializer.Deserialize(eventData2);
Assert.IsType <TestObject>(deserialized1);
Assert.IsType <TestObject>(deserialized2);
var result1 = (TestObject)deserialized1;
var result2 = (TestObject)deserialized2;
Assert.True(string.CompareOrdinal(result1.Data1, obj1.Data1) == 0);
Assert.True(string.CompareOrdinal(result2.Data1, obj2.Data1) == 0);
}
public void MessageIsSentWhenAmbientTransactionIsCommitted()
{
using (var tx = new TransactionScope())
{
var ctx = new AmbientTransactionContext();
senderQueue.Send(DestinationQueueName,
serializer.Serialize(new Message
{
Messages = new object[]
{
"W00t!"
},
}),
ctx);
tx.Complete();
}
var msmqMessage = Receive();
Assert.IsNotNull(msmqMessage, "No message was received within timeout!");
var transportMessage = (ReceivedTransportMessage)msmqMessage.Body;
var message = serializer.Deserialize(transportMessage);
message.Messages[0].ShouldBe("W00t!");
}
public void simple_object()
{
var obj = new Simple {
Test = "test"
};
var serialized = _serializer.Serialize(obj);
var deserialized = _serializer.Deserialize <Simple>(serialized);
Assert.AreEqual(obj.Test, deserialized.Test);
}
public void can_deserialize_to_a_specified_type()
{
var serializer = new JsonMessageSerializer();
var eventData = serializer.Serialize(testObject);
//n.b. testObject is type TestObject
var deserialized = serializer.Deserialize(eventData, typeof(TestObject2));
Assert.IsType <TestObject2>(deserialized);
var testObject2 = (TestObject2)deserialized;
Assert.True(string.CompareOrdinal(testObject.Data2, testObject2.Data2) == 0);
var newTestObject2 = serializer.Deserialize <TestObject2>(eventData);
Assert.True(string.CompareOrdinal(testObject.Data2, newTestObject2.Data2) == 0);
}
public void TestInterfaces()
{
var output = new MemoryStream();
var obj = messageMapper.CreateInstance <IA>(
x =>
{
x.S = "kalle";
x.I = 42;
x.Data = new byte[23];
x.B = new B
{
BString = "BOO",
C = new C
{
Cstr = "COO"
}
};
}
);
new Random().NextBytes(obj.Data);
messageMapper = new MessageMapper();
messageMapper.Initialize(new[]
{
typeof(IA), typeof(IAImpl)
});
serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
serializer.Serialize(obj, output);
output.Position = 0;
var filename = $"{GetType().Name}.{MethodBase.GetCurrentMethod().Name}.txt";
File.WriteAllBytes(filename, output.ToArray());
output.Position = 0;
var result = serializer.Deserialize(output, new[]
{
typeof(IAImpl)
});
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(1));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA)result[0];
Assert.AreEqual(a.Data, obj.Data);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C)a.B.C).Cstr);
}
public void Run()
{
var map = new[]
{
typeof(SuperMessageWithConcreteImpl),
typeof(ISuperMessageWithConcreteImpl)
};
var messageMapper = new MessageMapper();
messageMapper.Initialize(map);
var serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
var message = new SuperMessageWithConcreteImpl
{
SomeProperty = "test"
};
using (var stream = new MemoryStream())
{
serializer.Serialize(message, stream);
stream.Position = 0;
var result = (ISuperMessageWithConcreteImpl)serializer.Deserialize(stream, map)[0];
Assert.IsInstanceOf <SuperMessageWithConcreteImpl>(result);
Assert.AreEqual("test", result.SomeProperty);
}
}
public void WorksWhenMovingToErrorQueue()
{
using (var messageQueue = new MsmqMessageQueue("error"))
{
// make sure error queue is empty
messageQueue.PurgeInputQueue();
adapter.Handle <Request>(req =>
{
throw new ApplicationException("oh crap");
});
var request = new Request();
bus.AttachHeader(request, Headers.CorrelationId, "super-unique!!!!111");
bus.SendLocal(request);
// let it fail
Thread.Sleep(2.Seconds());
var receivedTransportMessage = messageQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var serializer = new JsonMessageSerializer();
var message = serializer.Deserialize(receivedTransportMessage);
message.Headers.ShouldContainKeyAndValue(Headers.CorrelationId, "super-unique!!!!111");
}
}
public void Should_throw_for_array()
{
var xml = @"[{
$type: ""IA, NServiceBus.Core.Tests"",
Data: ""rhNAGU4dr/Qjz6ocAsOs3wk3ZmxHMOg="",
S: ""kalle"",
I: 42,
B: {
}
}, {
$type: ""IA, NServiceBus.Core.Tests"",
Data: ""AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="",
S: ""kalle"",
I: 42,
B: {
}
}]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(xml);
streamWriter.Flush();
stream.Position = 0;
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
var exception = Assert.Throws <Exception>(() => serializer.Deserialize(stream, new List <Type>()));
Approvals.Verify(exception.Message);
}
}
public void ItHasBeenFixed()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle <string>(s =>
{
throw new ApplicationException("Will trigger that the message gets moved to the error queue");
});
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(ConnectionString, "test.input", "test.error")
.UseExchange("AlternativeExchange"))
.CreateBus()
.Start();
adapter.Bus.SendLocal("hello there!!!");
// wait until we're sure
Thread.Sleep(2.Seconds());
using (var errorQueue = new RabbitMqMessageQueue(ConnectionString, "test.error"))
{
var serializer = new JsonMessageSerializer();
var receivedTransportMessage = errorQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var errorMessage = serializer.Deserialize(receivedTransportMessage);
errorMessage.Messages.Length.ShouldBe(1);
errorMessage.Messages[0].ShouldBeOfType <string>();
((string)errorMessage.Messages[0]).ShouldBe("hello there!!!");
}
}
}
public void Should_throw_for_multiple_passed_type()
{
var text = @"
[{
SomeProperty: 'Value1'
},
{
SomeProperty: 'Value2'
}]";
using (var stream = new MemoryStream())
{
WriteToStream(stream, text);
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
var messageTypes = new List <Type>
{
typeof(ArrayMessage)
};
var exception = Assert.Throws <Exception>(() =>
{
serializer.Deserialize(stream, messageTypes);
});
Approver.Verify(exception.Message);
}
}
public void Deserialize_message_with_concrete_implementation_and_interface()
{
var map = new[] { typeof(SuperMessageWithConcreteImpl), typeof(ISuperMessageWithConcreteImpl) };
var messageMapper = new MessageMapper();
messageMapper.Initialize(map);
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
var msg = new SuperMessageWithConcreteImpl
{
SomeProperty = "test"
};
serializer.Serialize(msg, stream);
stream.Position = 0;
var result = (ISuperMessageWithConcreteImpl)serializer.Deserialize(stream, map)[0];
Assert.IsInstanceOf <SuperMessageWithConcreteImpl>(result);
Assert.AreEqual("test", result.SomeProperty);
}
}
void VerifyMessageHeaderIsPassed(Action <ISendContext <PingMessage> > setHeaderAction,
Action <IConsumeContext> checkHeaderAction)
{
byte[] data;
var serializer = new JsonMessageSerializer();
var message = new PingMessage();
using (var output = new MemoryStream())
{
var sendContext = new SendContext <PingMessage>(message);
setHeaderAction(sendContext);
serializer.Serialize(output, sendContext);
data = output.ToArray();
}
//Trace.WriteLine(Encoding.UTF8.GetString(data));
using (var input = new MemoryStream(data))
{
var receiveContext = ReceiveContext.FromBodyStream(input);
serializer.Deserialize(receiveContext);
checkHeaderAction(receiveContext);
}
}
public void Deserialize_private_message_with_two_unrelated_interface_without_wrapping()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(IMyEventA), typeof(IMyEventB) });
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
var msg = new CompositeMessage
{
IntValue = 42,
StringValue = "Answer"
};
serializer.Serialize(msg, stream);
stream.Position = 0;
var result = serializer.Deserialize(stream, new[] { typeof(IMyEventA), typeof(IMyEventB) });
var a = (IMyEventA)result[0];
var b = (IMyEventB)result[1];
Assert.AreEqual(42, b.IntValue);
Assert.AreEqual("Answer", a.StringValue);
}
}
public void Deserialize_messages_wrapped_in_array_from_older_endpoint()
{
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper);
var jsonWithMultipleMessages = @"
[
{
$type: 'NServiceBus.Serializers.Json.Tests.JsonMessageSerializerTest+SimpleMessage1, NServiceBus.Core.Tests',
PropertyOnMessage1: 'Message1'
},
{
$type: 'NServiceBus.Serializers.Json.Tests.JsonMessageSerializerTest+SimpleMessage2, NServiceBus.Core.Tests',
PropertyOnMessage2: 'Message2'
}
]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(jsonWithMultipleMessages);
streamWriter.Flush();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[]
{
typeof(SimpleMessage2),
typeof(SimpleMessage1)
});
Assert.AreEqual(2, result.Length);
Assert.AreEqual("Message1", ((SimpleMessage1)result[0]).PropertyOnMessage1);
Assert.AreEqual("Message2", ((SimpleMessage2)result[1]).PropertyOnMessage2);
}
}
public void Deserialize()
{
var messageMapper = new MessageMapper();
var messageTypes = new[]
{
typeof(IWithoutConcrete)
};
messageMapper.Initialize(messageTypes);
var serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
var message = messageMapper.CreateInstance <IWithoutConcrete>();
message.SomeProperty = "test";
using (var stream = new MemoryStream())
{
serializer.Serialize(message, stream);
stream.Position = 0;
var result = (IWithoutConcrete)serializer.Deserialize(stream, messageTypes)[0];
Assert.AreEqual("test", result.SomeProperty);
}
}
public void Run()
{
var messageMapper = new MessageMapper();
var messageTypes = new[]
{
typeof(IMyEventA),
typeof(IMyEventB)
};
messageMapper.Initialize(messageTypes);
var serializer = new JsonMessageSerializer(messageMapper, null, null, null, null);
var message = new CompositeMessage
{
IntValue = 42,
StringValue = "Answer"
};
using (var stream = new MemoryStream())
{
serializer.Serialize(message, stream);
stream.Position = 0;
var result = serializer.Deserialize(stream, messageTypes);
var a = (IMyEventA)result[0];
var b = (IMyEventB)result[1];
Assert.AreEqual(42, b.IntValue);
Assert.AreEqual("Answer", a.StringValue);
}
}
public async Task Send_works_for_already_passed_scheduled_time()
{
// Arrange
await ReceiveAndForgetAll();
IMessageSerializer serializer = new JsonMessageSerializer();
var sut = new ServiceBusMessageBus(_connectionStringBuilder, serializer);
var scheduled = new ScheduledEnvelope(
new Envelope(new Fixture().Create <SomeMessage>()),
DateTime.UtcNow.AddTicks(-TimeSpan.FromDays(1).Ticks));
// Act
await sut.Send(scheduled, CancellationToken.None);
// Assert
(Message received, DateTime receivedAt) = await ReceiveSingle();
var precision = TimeSpan.FromMilliseconds(1000);
receivedAt.Should().BeOnOrAfter(scheduled.ScheduledTimeUtc.AddTicks(-precision.Ticks));
object message = serializer.Deserialize(Encoding.UTF8.GetString(received.Body));
message.Should().BeEquivalentTo(scheduled.Envelope.Message);
}
public async Task Save_inserts_Memento_entity_correctly()
{
// Arrange
var sourceId = Guid.NewGuid();
var memento = new FakeUserMemento();
var serializer = new JsonMessageSerializer();
var sut = new SqlMementoStore(
() => new MementoStoreDbContext(_dbContextOptions),
serializer);
// Act
await sut.Save <FakeUser>(sourceId, memento, default);
// Assert
using (var db = new MementoStoreDbContext(_dbContextOptions))
{
Memento actual = await db
.Mementoes
.AsNoTracking()
.Where(m => m.AggregateId == sourceId)
.SingleOrDefaultAsync();
actual.Should().NotBeNull();
object restored = serializer.Deserialize(actual.MementoJson);
restored.Should().BeOfType <FakeUserMemento>();
restored.ShouldBeEquivalentTo(memento);
}
}
/// <summary>
/// Deserializes the specified message.
/// </summary>
/// <param name="messageType">The type of message.</param>
/// <param name="revision">The revision of the message.</param>
/// <param name="message">The message to deserialize.</param>
/// <returns>A deserialized <see cref="IEvent">event</see>.</returns>
protected virtual IEvent Deserialize(string messageType, int revision, JObject message)
{
Arg.NotNullOrEmpty(messageType, nameof(messageType));
Arg.NotNull(message, nameof(message));
Contract.Ensures(Contract.Result <IEvent>() != null);
return(eventSerializer.Deserialize(messageType, revision, message));
}
public void can_round_trip()
{
var employee1 = new Employee()
{
Name = "Austin"
};
var stream = new MemoryStream();
_serializer.Serialize(employee1, stream);
stream.Position = 0;
var employee2 = _serializer.Deserialize(stream).ShouldBeOfType <Employee>();
employee1.ShouldBe(employee2);
}
public void TestMethod()
{
int msgCount = 5000;
IMessageSerializer json = new JsonMessageSerializer();
IMessageSerializer bson = new BsonMessageSerializer();
long elapsed1;
long elapsed2;
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < msgCount; i++)
{
IMessage msg = new MessageSerDes() { Content = "Hello world people" };
using (MemoryStream ms = new MemoryStream())
{
json.Serialize(msg, ms);
if (ms.CanSeek)
ms.Seek(0, SeekOrigin.Begin);
var des = json.Deserialize(ms);
if ((des as MessageSerDes).Content != (msg as MessageSerDes).Content ||
(des as MessageSerDes).Id != (msg as MessageSerDes).Id ||
(des as MessageSerDes).Age != (msg as MessageSerDes).Age)
Assert.Fail();
}
msg = null;
}
sw.Stop();
elapsed1 = sw.ElapsedMilliseconds;
sw.Reset();
sw.Start();
for (int i = 0; i < msgCount; i++)
{
IMessage msg = new MessageSerDes() { Content = "Hello world people" };
using (MemoryStream ms = new MemoryStream())
{
bson.Serialize(msg, ms);
if (ms.CanSeek)
ms.Seek(0, SeekOrigin.Begin);
var des = bson.Deserialize(ms);
if ((des as MessageSerDes).Content != (msg as MessageSerDes).Content ||
(des as MessageSerDes).Id != (msg as MessageSerDes).Id ||
(des as MessageSerDes).Age != (msg as MessageSerDes).Age)
Assert.Fail();
}
msg = null;
}
sw.Stop();
elapsed2 = sw.ElapsedMilliseconds;
Assert.AreNotEqual(elapsed1, elapsed2);
}
public void can_throw_if_type_not_found()
{
var serializer = new JsonMessageSerializer();
//n.b. setting header to non existent assembly
var headerName = serializer.EventClrQualifiedTypeHeader;
var headerData = $"{typeof(TestObject2).FullName},dne-assembly";
var headers = new Dictionary <string, object> {
{ headerName, headerData }
};
var eventData = serializer.Serialize(testObject, headers);
//confirm type not found
var deserialized = serializer.Deserialize(eventData);
Assert.IsType <JObject>(deserialized);
//request throw on type not found
serializer.ThrowOnTypeNotFound = true;
Assert.Throws <InvalidOperationException>(() => serializer.Deserialize(eventData));
}
public void can_serialize_objects()
{
var serializer = new JsonMessageSerializer();
var eventData = serializer.Serialize(testObject);
var deserialized = serializer.Deserialize(eventData);
Assert.IsType <TestObject>(deserialized);
var testObject2 = (TestObject)deserialized;
Assert.True(testObject.Equals(testObject2));
serializer.FullyQualify = true;
eventData = serializer.Serialize(testObject);
deserialized = serializer.Deserialize(eventData);
Assert.IsType <TestObject>(deserialized);
var testObject3 = (TestObject)deserialized;
Assert.True(testObject.Equals(testObject3));
}
public void When_Using_Property_WithXContainerAssignable_should_preserve_xml()
{
const string XmlElement = "<SomeClass xmlns=\"http://nservicebus.com\"><SomeProperty value=\"Bar\" /></SomeClass>";
const string XmlDocument = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + XmlElement;
var messageWithXDocument = new MessageWithXDocument {
Document = XDocument.Load(new StringReader(XmlDocument))
};
var messageWithXElement = new MessageWithXElement {
Document = XElement.Load(new StringReader(XmlElement))
};
var messageMapper = new MessageMapper();
var serializer = new JsonMessageSerializer(messageMapper);
using (var stream = new MemoryStream())
{
serializer.Serialize(messageWithXDocument, stream);
stream.Position = 0;
var json = new StreamReader(stream).ReadToEnd();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[] { typeof(MessageWithXDocument) }).Cast <MessageWithXDocument>().Single();
Assert.AreEqual(messageWithXDocument.Document.ToString(), result.Document.ToString());
Assert.AreEqual(XmlElement, json.Substring(13, json.Length - 15).Replace("\\", string.Empty));
}
using (var stream = new MemoryStream())
{
serializer.Serialize(messageWithXElement, stream);
stream.Position = 0;
var json = new StreamReader(stream).ReadToEnd();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[] { typeof(MessageWithXElement) }).Cast <MessageWithXElement>().Single();
Assert.AreEqual(messageWithXElement.Document.ToString(), result.Document.ToString());
Assert.AreEqual(XmlElement, json.Substring(13, json.Length - 15).Replace("\\", string.Empty));
}
}
public async Task SaveEvents_saves_pending_events_correctly()
{
// Arrange
var userId = Guid.NewGuid();
var created = new FakeUserCreated();
var usernameChanged = new FakeUsernameChanged();
var events = new DomainEvent[] { created, usernameChanged };
events.Raise(userId);
var serializer = new JsonMessageSerializer();
var sut = new SqlEventStore(
() => new FakeEventStoreDbContext(_dbContextOptions),
serializer);
string operationId = Guid.NewGuid().ToString();
var correlationId = Guid.NewGuid();
string contributor = Guid.NewGuid().ToString();
// Act
await sut.SaveEvents <FakeUser>(events, operationId, correlationId, contributor);
// Asseert
using (var db = new FakeEventStoreDbContext(_dbContextOptions))
{
var pendingEvents = db
.PendingEvents
.Where(e => e.AggregateId == userId)
.OrderBy(e => e.Version)
.ToList();
foreach (var t in pendingEvents.Zip(events, (pending, source) =>
new { Pending = pending, Source = source }))
{
var actual = new
{
t.Pending.Version,
t.Pending.CorrelationId,
t.Pending.Contributor,
Message = serializer.Deserialize(t.Pending.EventJson),
};
actual.ShouldBeEquivalentTo(new
{
t.Source.Version,
OperationId = operationId,
CorrelationId = correlationId,
Contributor = contributor,
Message = t.Source,
},
opts => opts.RespectingRuntimeTypes());
}
}
}
public void TestMany()
{
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(IAImpl), typeof(IA) });
var serializer = new JsonMessageSerializer(messageMapper);
var xml = @"[{
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""rhNAGU4dr/Qjz6ocAsOs3wk3ZmxHMOg="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}, {
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(xml);
streamWriter.Flush();
stream.Position = 0;
var result = serializer.Deserialize(stream, new[] { typeof(IAImpl) });
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(2));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = (IA)result[0];
Assert.AreEqual(23, a.Data.Length);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C)a.B.C).Cstr);
}
}
public void Deserialize_ShouldThrowWhenNotSuccessful(
[Frozen] Mock <ISerializer> serializer,
JsonMessageSerializer sut,
string data, Type type)
{
serializer.Setup(x => x.Deserialize(data, type))
.Returns(null);
Assert.Throws <InvalidOperationException>(
() => sut.Deserialize(data, type));
}
public void Deserialize_NotATextMessage_ThrowsInvalidCastException()
{
// arrange
var message = new BytesMessage();
// act
var serializer = new JsonMessageSerializer <TestBody>();
// assert
Assert.Throws <InvalidCastException>(() => serializer.Deserialize(message));
}
public void can_use_json_message_serializer()
{
var evt = new TestEvent(CorrelatedMessage.NewRoot());
var evt2 = new TestEvent(evt);
var serializer = new JsonMessageSerializer();
var data = serializer.Serialize(evt);
var data2 = serializer.Serialize(evt2);
var dEvent = (TestEvent)serializer.Deserialize(data);
var dEvent2 = (TestEvent)serializer.Deserialize(data2);
Assert.Equal(evt.MsgId, dEvent.MsgId);
Assert.Equal(evt.SourceId, dEvent.SourceId);
Assert.Equal(evt.CorrelationId, dEvent.CorrelationId);
Assert.Equal(evt2.MsgId, dEvent2.MsgId);
Assert.Equal(evt2.SourceId, dEvent2.SourceId);
Assert.Equal(evt2.CorrelationId, dEvent2.CorrelationId);
}
public void Deserialize_ShouldDeserialize(
[Frozen] Mock <ISerializer> serializer,
JsonMessageSerializer sut,
string data, Type type, object deserialized)
{
serializer.Setup(x => x.Deserialize(data, type))
.Returns(deserialized);
var result = sut.Deserialize(data, type);
Assert.Equal(deserialized, result);
}
public void TestMany()
{
var xml = @"[{
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""rhNAGU4dr/Qjz6ocAsOs3wk3ZmxHMOg="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}, {
$type: ""NServiceBus.Serializers.Json.Tests.IA, NServiceBus.Core.Tests"",
Data: ""AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="",
S: ""kalle"",
I: 42,
B: {
BString: ""BOO"",
C: {
$type: ""NServiceBus.Serializers.Json.Tests.C, NServiceBus.Core.Tests"",
Cstr: ""COO""
}
}
}]";
using (var stream = new MemoryStream())
{
var streamWriter = new StreamWriter(stream);
streamWriter.Write(xml);
streamWriter.Flush();
stream.Position = 0;
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IAImpl), typeof(IA) });
Serializer = new JsonMessageSerializer(MessageMapper);
var result = Serializer.Deserialize(stream, new[] { typeof(IAImpl) });
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(2));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = ((IA) result[0]);
Assert.AreEqual(23, a.Data.Length);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C) a.B.C).Cstr);
}
}
public void send_and_receive_on_conversation_channel() {
var myQ = Broker.CreateQueue("MyQueue");
var myMessage = Broker.CreateMessageType("System.String");
var myContract = Broker.CreateContract("MyContract2", new [] { myMessage }, new[] { myMessage });
var myService = myQ.CreateService("MyQueue", myContract);
var c1 = Broker.BeginConversation(myService, myService, myContract);
var channel = Broker.OpenConversationChannel(c1);
channel.Send("Hello World");
var json = new JsonMessageSerializer();
ServiceBrokerMessageHandler getHelloSendGoodbye = (c, t, b) => {
Check.That(() => json.Deserialize(b, t).ToString() == "Hello World");
Broker.OpenConversationChannel(c).Send("Goodbye World!");
};
Check.That(() => myQ.TryReceive(getHelloSendGoodbye, TimeSpan.Zero));
Action<string,object> checkGoodbye = (t, b) => Check.That(() => (string)b == "Goodbye World!");
Check.That(() => channel.TryReceive(checkGoodbye, TimeSpan.Zero));
}
public void Deserialize_message_without_concrete_implementation()
{
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(ISuperMessageWithoutConcreteImpl) });
Serializer = new JsonMessageSerializer(MessageMapper);
using (var stream = new MemoryStream())
{
var msg = MessageMapper.CreateInstance<ISuperMessageWithoutConcreteImpl>();
msg.SomeProperty = "test";
Serializer.Serialize(msg, stream);
stream.Position = 0;
var result = (ISuperMessageWithoutConcreteImpl)Serializer.Deserialize(stream, new[] { typeof(ISuperMessageWithoutConcreteImpl) })[0];
Assert.AreEqual("test", result.SomeProperty);
}
}
public void Deserialize_message_with_concrete_implementation_and_interface()
{
var map = new[] {typeof(SuperMessageWithConcreteImpl), typeof(ISuperMessageWithConcreteImpl)};
MessageMapper = new MessageMapper();
MessageMapper.Initialize(map);
Serializer = new JsonMessageSerializer(MessageMapper);
using (var stream = new MemoryStream())
{
var msg = new SuperMessageWithConcreteImpl
{
SomeProperty = "test"
};
Serializer.Serialize(msg, stream);
stream.Position = 0;
var result = (ISuperMessageWithConcreteImpl)Serializer.Deserialize(stream, map)[0];
Assert.IsInstanceOf<SuperMessageWithConcreteImpl>(result);
Assert.AreEqual("test", result.SomeProperty);
}
}
public void Test()
{
var expectedDate = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Unspecified);
var expectedDateLocal = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Local);
var expectedDateUtc = new DateTime(2010, 10, 13, 12, 32, 42, DateTimeKind.Utc);
var expectedGuid = Guid.NewGuid();
var obj = new A
{
AGuid = expectedGuid,
Data = new byte[32],
I = 23,
S = "Foo",
Ints = new List<int> { 12, 42 },
Bs = new List<B> { new B { BString = "aaa", C = new C { Cstr = "ccc" } }, new BB { BString = "bbbb", C = new C { Cstr = "dddd" }, BBString = "BBStr"} },
DateTime = expectedDate,
DateTimeLocal = expectedDateLocal,
DateTimeUtc = expectedDateUtc
};
new Random().NextBytes(obj.Data);
var output = new MemoryStream();
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IA), typeof(A) });
Serializer = new JsonMessageSerializer(MessageMapper);
Serializer.Serialize(obj, output);
output.Position = 0;
var result = Serializer.Deserialize(output, new[] { typeof(A) });
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.That(result[0], Is.TypeOf(typeof(A)));
var a = ((A)result[0]);
Assert.AreEqual(obj.Data, a.Data);
Assert.AreEqual(23, a.I);
Assert.AreEqual("Foo", a.S);
Assert.AreEqual(expectedDate.Kind, a.DateTime.Kind);
Assert.AreEqual(expectedDate, a.DateTime);
Assert.AreEqual(expectedDateLocal.Kind, a.DateTimeLocal.Kind);
Assert.AreEqual(expectedDateLocal, a.DateTimeLocal);
Assert.AreEqual(expectedDateUtc.Kind, a.DateTimeUtc.Kind);
Assert.AreEqual(expectedDateUtc, a.DateTimeUtc);
Assert.AreEqual("ccc", ((C)a.Bs[0].C).Cstr);
Assert.AreEqual(expectedGuid, a.AGuid);
Assert.IsInstanceOf<B>(a.Bs[0]);
Assert.IsInstanceOf<BB>(a.Bs[1]);
}
public void TestInterfaces()
{
var output = new MemoryStream();
var obj = MessageMapper.CreateInstance<IA>(
x =>
{
x.S = "kalle";
x.I = 42;
x.Data = new byte[23];
x.B = new B { BString = "BOO", C = new C { Cstr = "COO" } };
}
);
new Random().NextBytes(obj.Data);
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IA), typeof(IAImpl) });
Serializer = new JsonMessageSerializer(MessageMapper);
Serializer.Serialize(obj, output);
output.Position = 0;
var filename = string.Format("{0}.{1}.txt", GetType().Name, MethodBase.GetCurrentMethod().Name);
File.WriteAllBytes(filename, output.ToArray());
output.Position = 0;
var result = Serializer.Deserialize(output, new[] { typeof(IAImpl) });
Assert.DoesNotThrow(() => output.Position = 0, "Stream should still be open");
Assert.IsNotEmpty(result);
Assert.That(result, Has.Length.EqualTo(1));
Assert.That(result[0], Is.AssignableTo(typeof(IA)));
var a = ((IA)result[0]);
Assert.AreEqual(a.Data, obj.Data);
Assert.AreEqual(42, a.I);
Assert.AreEqual("kalle", a.S);
Assert.IsNotNull(a.B);
Assert.AreEqual("BOO", a.B.BString);
Assert.AreEqual("COO", ((C)a.B.C).Cstr);
}
public void Deserialize_private_message_with_two_unrelated_interface_without_wrapping()
{
MessageMapper = new MessageMapper();
MessageMapper.Initialize(new[] { typeof(IMyEventA), typeof(IMyEventB) });
Serializer = new JsonMessageSerializer(MessageMapper);
using (var stream = new MemoryStream())
{
var msg = new CompositeMessage
{
IntValue = 42,
StringValue = "Answer"
};
Serializer.Serialize(msg, stream);
stream.Position = 0;
var result = Serializer.Deserialize(stream, new[] { typeof(IMyEventA), typeof(IMyEventB) });
var a = (IMyEventA) result[0];
var b = (IMyEventB) result[1];
Assert.AreEqual(42, b.IntValue);
Assert.AreEqual("Answer", a.StringValue);
}
}