public void MessageExpirationWorks() { // arrange var timeToBeReceived = 2.Seconds().ToString(); const string recipientInputQueueName = "test.expiration.recipient"; const string senderInputQueueName = "test.expiration.sender"; using (var recipientQueue = new RabbitMqMessageQueue(ConnectionString, recipientInputQueueName)) using (var senderQueue = new RabbitMqMessageQueue(ConnectionString, senderInputQueueName)) { senderQueue.Send(recipientInputQueueName, serializer.Serialize(new Message { Messages = new object[] { "HELLO WORLD!" }, Headers = new Dictionary <string, object> { { Headers.TimeToBeReceived, timeToBeReceived } }, }), new NoTransaction()); // act Thread.Sleep(2.Seconds() + 1.Seconds()); // assert var receivedTransportMessage = recipientQueue.ReceiveMessage(new NoTransaction()); Assert.That(receivedTransportMessage, Is.Null); } }
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_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 FromScheduledEnvelope_generates_PendingScheduledCommand_correctly() { // Arrange var random = new Random(); var processManager = new FakeProcessManager(); var messageId = Guid.NewGuid(); var correlationId = Guid.NewGuid(); var message = new FakeCommand { Int32Value = random.Next(), StringValue = Guid.NewGuid().ToString(), }; var scheduledEnvelope = new ScheduledEnvelope( new Envelope(messageId, message, correlationId: correlationId), DateTime.Now.AddTicks(random.Next())); var serializer = new JsonMessageSerializer(); // Act var actual = PendingScheduledCommand.FromScheduledEnvelope(processManager, scheduledEnvelope, serializer); // Assert actual.ProcessManagerType.Should().Be(typeof(FakeProcessManager).FullName); actual.ProcessManagerId.Should().Be(processManager.Id); actual.MessageId.Should().Be(messageId); actual.CorrelationId.Should().Be(correlationId); actual.CommandJson.Should().Be(serializer.Serialize(message)); actual.ScheduledTimeUtc.Should().Be(scheduledEnvelope.ScheduledTimeUtc); }
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_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); } }
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 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 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 Should_not_emit_UTF8_BOM_if_configured_not_to() { var messageMapper = new MessageMapper(); Func <Stream, JsonWriter> writerCreator = stream => { var streamWriter = new StreamWriter(stream, new UTF8Encoding(false, false)); return(new JsonTextWriter(streamWriter) { Formatting = Formatting.None }); }; var serializer = new JsonMessageSerializer(messageMapper, null, writerCreator, null, null); var message = new SimpleMessage(); using (var stream = new MemoryStream()) { serializer.Serialize(message, stream); stream.Position = 0; var result = stream.ToArray(); var utf8bom = new UTF8Encoding(true).GetPreamble(); for (var i = 0; i < utf8bom.Length; i++) { Assert.AreNotEqual(utf8bom[i], result[i]); } } }
public void can_write_qualified_name_header() { var serializer = new JsonMessageSerializer(); var eventData = serializer.Serialize(testObject); var clrQualifiedName = (string)JObject.Parse(Encoding.UTF8.GetString(eventData.Metadata)) .Property(serializer.EventClrQualifiedTypeHeader).Value; var partialName = $"{testObject.GetType().FullName},{testObject.GetType().Assembly.GetName()}"; Assert.True(string.CompareOrdinal(clrQualifiedName, partialName) == 0); serializer.FullyQualify = true; eventData = serializer.Serialize(testObject); clrQualifiedName = (string)JObject.Parse(Encoding.UTF8.GetString(eventData.Metadata)) .Property(serializer.EventClrQualifiedTypeHeader).Value; Assert.True(string.CompareOrdinal(clrQualifiedName, testObject.GetType().AssemblyQualifiedName) == 0); }
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_write_typename_header() { var serializer = new JsonMessageSerializer(); var eventData = serializer.Serialize(testObject); var typeName = (string)JObject.Parse(Encoding.UTF8.GetString(eventData.Metadata)) .Property(serializer.EventClrTypeHeader).Value; Assert.True(string.CompareOrdinal(typeName, testObject.GetType().Name) == 0); }
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 Serialize <T>(Stream stream, SendContext <T> context) where T : class { var messageContainer = context.Message as MessageContainer; if (messageContainer != null) { _changeMessageTypeSerializer.Serialize(stream, context); } _jsonSerializer.Serialize(stream, context); }
public void Serialize_ByteArray_ReturnedUnmodified() { var messageBytes = Encoding.UTF8.GetBytes("test"); var serializer = new JsonMessageSerializer(); var serialized = serializer.Serialize(messageBytes, new MessageHeaderCollection()); serialized.Should().BeSameAs(messageBytes); }
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)); } }
private async Task ProcessMessageAsync(RestoreMessage restoreMessage) { var currentDate = restoreMessage.FromDate.ToUniversalTime(); var to = restoreMessage.ToDate.ToUniversalTime(); var bindings = await _rabbitService.GetAllBindingsAsync(); var exchangeBindings = bindings[restoreMessage.ExchangeName] .Where(x => x.DestinationType == "queue") .ToList(); while (currentDate.Date <= to.Date) { string continuationToken = null; do { var result = await _rabbitService.RestoreMessageAsync(restoreMessage.ExchangeName, currentDate, 100, continuationToken); var factory = new ConnectionFactory() { Uri = _connectionString, }; foreach (var binding in exchangeBindings) { using (var connection = factory.CreateConnection()) using (var channel = connection.CreateModel()) { foreach (var message in result.Messages) { //channel.QueueDeclare(queue: "hello", // durable: false, // exclusive: false, // autoDelete: false, // arguments: null); var body = _messageSerializer.Serialize(message.Payload); channel.BasicPublish(exchange: "", routingKey: binding.Destination, basicProperties: null, body: body); } } continuationToken = result.ContinuationToken; } currentDate = currentDate.AddDays(1.0); } while (!string.IsNullOrEmpty(continuationToken)); } }
public void Serialize_ShouldSerialize( [Frozen] Mock <ISerializer> serializer, JsonMessageSerializer sut, object data, string serialized) { serializer.Setup(x => x.Serialize(data)) .Returns(serialized); var result = sut.Serialize(data); Assert.Equal(serialized, result); }
public void Low_Level_Transport_Test() { var clientManager = new PooledRedisClientManager(); var messageMapper = new MessageMapper(); messageMapper.Initialize(new[] { typeof(TestMessage), typeof(TestEvent) }); var sendAddress = Address.Parse("lowlevel@localhost"); var queue = new RedisQueue(new JsonSerializer(), clientManager, new QueueKeyNameProvider(true)); queue.Init(sendAddress, true); var nsbSerializer = new JsonMessageSerializer(messageMapper); var message = new TestMessage() { Name = "Bob" }; var transportMessage = new TransportMessage() { MessageIntent = MessageIntentEnum.Send }; using (var ms = new MemoryStream()) { nsbSerializer.Serialize(new [] { message }, ms); transportMessage.Body = ms.ToArray(); } using (var tran = new TransactionScope()) { for (int x = 0; x < 2; x++) { queue.Send(transportMessage, sendAddress); } tran.Complete(); } for (int x = 0; x < 2; x++) { if (queue.HasMessage()) { using (var tran = new TransactionScope()) { queue.Receive(); tran.Complete(); } } } }
public static string Serialize(object sagaEntity) { using (var memoryStream = new MemoryStream()) { serializer.Serialize(new[] { sagaEntity }, memoryStream); memoryStream.Position = 0; using (var streamReader = new StreamReader(memoryStream)) { return(streamReader.ReadToEnd()); } } }
public void MessageExpirationWorks() { // arrange var timeToBeReceived = 2.Seconds() .ToString(); senderQueue.Send(destinationQueueName, serializer.Serialize(new Message { Messages = new object[] { "HELLO WORLD!" }, Headers = new Dictionary <string, string> { { Headers.TimeToBeReceived, timeToBeReceived } }, })); // act Thread.Sleep(2.Seconds() + 1.Seconds()); // assert Assert.Throws <MessageQueueException>(() => destinationQueue.Receive(0.1.Seconds())); }
public void JsonMessageSerializer_SerializesEventProperly() { var sut = new JsonMessageSerializer(); var value = Guid.NewGuid().ToString(); var aggregateId = Guid.NewGuid(); var @event = new FakeEvent(aggregateId, 1, value); var bytes = sut.Serialize(@event); Assert.NotNull(bytes); Assert.NotEmpty(bytes); }
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 ShouldDeserializeFromJson() { IMessageSerializer serializer = new JsonMessageSerializer(); IMessageDeserializer <TestMessageProto> deserializer = new JsonMessageDeserializer <TestMessageProto>(); var message = new TestMessageProto { Id = 123, Name = "SomeName" }; var serialize = serializer.Serialize(message); var deserialize = deserializer.Deserialize(serialize); Assert.AreEqual(message, deserialize); }
public void WorksWithCustomEncodingAsWell(string encodingWebName) { // arrange var encoding = Encoding.GetEncoding(encodingWebName); serializer.SpecifyEncoding(encoding); // act var transportMessageToSend = serializer.Serialize(new Message { Messages = new object[] { "hej!" } }); // assert transportMessageToSend.Headers.ShouldContainKeyAndValue(Headers.Encoding, encoding.WebName); transportMessageToSend.Headers.ShouldContainKeyAndValue(Headers.ContentType, "text/json"); encoding.GetString(transportMessageToSend.Body) .Replace("\r", "") .Replace("\n", "") .Replace(" ", "") .ShouldBe(@"{""$type"":""System.Object[],mscorlib"",""$values"":[""hej!""]}"); }
public void Deliver(string text) { var message = new Message { Headers = new Dictionary <string, object>(), Messages = new object[] { text } }; var transportMessage = serializer.Serialize(message); subliminalMessages.Enqueue(transportMessage.ToReceivedTransportMessage()); }
public void ShouldSerializeToJson() { IMessageSerializer serializer = new JsonMessageSerializer(); var message = new TestMessageProto { Id = 123, Name = "SomeName" }; var serialize = JsonMessageDefaults.Encoding.GetString(serializer.Serialize(message)); Assert.NotNull(serialize); StringAssert.Contains(message.Id.ToString(), serialize); StringAssert.Contains(message.Name, serialize); }
public void An_interface_message_is_bound() { _serializer = new JsonMessageSerializer(); var message = new A {TextA = "ValueA"}; using(var buffer = new MemoryStream()) { _serializer.Serialize<A>(buffer, message.ToSendContext()); _message = Encoding.UTF8.GetString(buffer.ToArray()); // Trace.WriteLine(_message); } }
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 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 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 Serialize_message_without_concrete_implementation() { MessageMapper = new MessageMapper(); MessageMapper.Initialize(new[] { typeof(ISuperMessageWithoutConcreteImpl) }); Serializer = new JsonMessageSerializer(MessageMapper); using (var stream = new MemoryStream()) { Serializer.Serialize(MessageMapper.CreateInstance<ISuperMessageWithoutConcreteImpl>(), stream); stream.Position = 0; var result = new StreamReader(stream).ReadToEnd(); Assert.That(!result.Contains("$type"), result); Assert.That(result.Contains("SomeProperty"), result); } }
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); } }