public void Can_roundtrip_with_datetime_on_non_english_culture(string cultureName)
{
var oldCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo(cultureName);
try
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
var date = DateTime.Now;
serializer.Serialize(new object[] { new Bar {
Date = date
} }, stream);
stream.Position = 0;
var bar = (Bar)serializer.Deserialize(stream)[0];
Assert.Equal(date, bar.Date);
}
finally
{
Thread.CurrentThread.CurrentCulture = oldCulture;
}
}
public void Can_handle_dictionaries_where_values_are_objects()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[] { new ItemWithObjectDictionary()
{
Name = "abc", Arguments = new Dictionary <string, object>
{
{ "abc", "cdef" },
{ "def", 1 },
{ "123", new Dog {
Name = "Oscar"
} }
}
} }, stream);
stream.Position = 0;
stream.Position = 0;
var foo = (ItemWithObjectDictionary)serializer.Deserialize(stream)[0];
Assert.Equal("abc", foo.Name);
Assert.Equal("cdef", foo.Arguments["abc"]);
Assert.Equal(1, (int)foo.Arguments["def"]);
Assert.Equal("Oscar", ((Dog)foo.Arguments["123"]).Name);
}
public void The_xml_message_serializer_should_rock_the_house()
{
byte[] serializedMessageData;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(x =>
{
x.SetSourceAddress("msmq://localhost/queue_name");
x.SetDestinationAddress("msmq://remotehost/queue_name");
x.SetResponseAddress("msmq://localhost/response_queue");
x.SetFaultAddress("msmq://localhost/fault_queue");
x.SetRetryCount(7);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, _message);
serializedMessageData = output.ToArray();
Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData));
}
using (MemoryStream input = new MemoryStream(serializedMessageData))
{
SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage;
Assert.AreEqual(_message, receivedMessage);
}
}
private void VerifyMessageHeaderIsPassed(Action <IOutboundMessage> setHeaderAction, Action <IInboundMessageHeaders> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(setHeaderAction);
var message = new PingMessage();
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
serializer.Deserialize(input);
checkHeaderAction(CurrentMessage.Headers);
}
}
public void MoveErrorMessageToOriginQueue(QueueItem itm)
{
if (string.IsNullOrEmpty(itm.Id))
{
throw new ArgumentException("MessageId can not be null or empty");
}
if (itm.Queue.Type != QueueType.Error)
{
throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type);
}
var mgr = new ErrorManager();
// TODO:
// Check if Clustered Queue, due if Clustered && NonTransactional, then Error
//var deserializer = new XmlMessageSerializer();
XmlMessageSerializer _serializer = new XmlMessageSerializer();
using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? "")))
{
var rcx = ReceiveContext.FromBodyStream(stream);
_serializer.Deserialize(rcx);
//var query = rcx.DestinationAddress.Query;
//var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error";
//mgr.InputQueue = new EndpointAddress(errorQueue);
mgr.ReturnMessageToSourceQueue(itm.Id, rcx);
}
}
public void Will_move_poision_message_to_error_queue()
{
transport.MessageArrived += information =>
{
throw new InvalidOperationException("problem");
};
using (var tx = new TransactionScope())
{
transport.Send(transport.Endpoint, new object[] { "test" });
tx.Complete();
}
using (var tx = new TransactionScope())
{
var message = transport.Queue.Receive(SubQueue.Errors.ToString());
Assert.Equal("test", messageSerializer.Deserialize(new MemoryStream(message.Data))[0]);
var errMsg = transport.Queue.Receive(SubQueue.Errors.ToString());
Assert.True(Encoding.Unicode.GetString(errMsg.Data).StartsWith("System.InvalidOperationException: problem"));
Assert.Equal(message.Id.ToString(), errMsg.Headers["correlation-id"]);
Assert.Equal("5", errMsg.Headers["retries"]);
tx.Complete();
}
}
void VerifyMessageHeaderIsPassed(Action <ISendContext <PingMessage> > setHeaderAction,
Action <IConsumeContext> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
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);
}
}
private void VerifyMessageHeaderIsPassed(Action<IOutboundMessage> setHeaderAction, Action<IInboundMessageHeaders> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(setHeaderAction);
var message = new PingMessage();
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
serializer.Deserialize(input);
checkHeaderAction(CurrentMessage.Headers);
}
}
public void Deserialize_BytesMessage_Exception()
{
var serializer = new XmlMessageSerializer <BytesMessage>();
var message = new TextMessage {
Body = MessageText
};
Assert.Throws <InvalidOperationException>(() => serializer.Deserialize(message));
}
public void Should_deserialize_into_the_proxy_object()
{
XmlMessageSerializer serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(InterfaceBasedMessageXml)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
}
}
public void can_deserialize_rhino_esb_message()
{
var writer = new StreamWriter(_stream);
writer.Write(XmlInput);
writer.Flush();
_stream.Position = 0;
var result = (TestRhinoToFtSerialization) _serializer.Deserialize(_stream);
result.Id.ShouldEqual(1);
}
public void Deserialize_TextMessage_CorrectResult()
{
var serializer = new XmlMessageSerializer <TextMessage>();
var result = serializer.Deserialize(new TextMessage {
Body = MessageText
});
Assert.That(result.Body == "testMessage");
}
public void Can_serialize_and_deserialize_byte_array()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream);
stream.Position = 0;
var actual = (byte[])serializer.Deserialize(stream)[0];
Assert.Equal(new byte[] { 1, 2, 3, 4 }, actual);
}
public void Should_deserialize_into_the_proxy_object()
{
XmlMessageSerializer serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(InterfaceBasedMessageXml)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
}
}
public void Deserialize_BytesMessage_CastResult()
{
var serializer = new XmlMessageSerializer <TextMessage>();
var message = new BytesMessage {
Body = Encoding.UTF8.GetBytes(MessageText)
};
var result = serializer.Deserialize(message);
Assert.That(result.Body == "testMessage");
}
public void Can_serialize_and_deserialize_byte_array()
{
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream);
stream.Position = 0;
var actual = (byte[])serializer.Deserialize(stream).As <byte[]>();
new byte[] { 1, 2, 3, 4 }.ShouldEqual(actual);
}
public void Should_not_cause_fatal_explosions_of_the_fiery_death_kind()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(Version4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf<ComplaintAdded>(obj);
}
}
public void Should_handle_the_uri_type()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(AnotherVersion4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf<ComplaintAdded>(obj);
}
}
public void Can_serialize_and_deserialize_primitive()
{
long ticks = DateTime.Now.Ticks;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { ticks }, stream);
stream.Position = 0;
var actual = (long)serializer.Deserialize(stream)[0];
Assert.Equal(ticks, actual);
}
public void Can_serialize_and_deserialize_DateTimeOffset()
{
var value = DateTimeOffset.Now;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { value }, stream);
stream.Position = 0;
var actual = (DateTimeOffset)serializer.Deserialize(stream)[0];
Assert.Equal(value, actual);
}
public void Should_handle_the_uri_type()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(AnotherVersion4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf <ComplaintAdded>(obj);
}
}
public void Can_serialize_and_deserialize_float()
{
float aFloat = 1.12f;
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { aFloat }, stream);
stream.Position = 0;
var actual = (float)serializer.Deserialize(stream).As <float>();
aFloat.ShouldEqual(actual);
}
public void Can_serialize_and_deserialize_double()
{
double aDouble = 1.12;
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { aDouble }, stream);
stream.Position = 0;
var actual = (double)serializer.Deserialize(stream).As <double>();
aDouble.ShouldEqual(actual);
}
public void Can_serialize_and_deserialize_primitive()
{
long ticks = DateTime.Now.Ticks;
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { ticks }, stream);
stream.Position = 0;
var actual = (long)serializer.Deserialize(stream).As <long>();
ticks.ShouldEqual(actual);
}
public void Can_serialize_and_deserialize_float()
{
float aFloat = 1.12f;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[] { aFloat }, stream);
stream.Position = 0;
var actual = (float)serializer.Deserialize(stream)[0];
Assert.Equal(aFloat, actual);
}
public void Should_not_cause_fatal_explosions_of_the_fiery_death_kind()
{
var serializer = new XmlMessageSerializer();
using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(Version4Message)))
{
object obj = serializer.Deserialize(bodyStream);
Assert.IsNotNull(obj);
Assert.IsInstanceOf <ComplaintAdded>(obj);
}
}
public void Can_serialize_and_deserialize_DateTimeOffset()
{
var value = DateTimeOffset.Now;
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(new object[] { value }, stream);
stream.Position = 0;
var actual = (DateTimeOffset)serializer.Deserialize(stream).As <DateTimeOffset>();
value.ShouldEqual(actual);
}
public void can_serialize_and_deserialize_icpc_monitor()
{
var ms = new MemoryStream();
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var submission = S("testuser A AC 11");
var builder = new IcpcMonitorBuilder(contest);
object monitor = builder.BuildMonitor(new[] { submission });
serializer.Serialize(new[] { monitor }, ms);
ms.Position = 0;
serializer.Deserialize(ms);
}
public void Can_serialize_and_deserialize_double()
{
double aDouble = 1.12;
var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[] { aDouble }, stream);
stream.Position = 0;
var actual = (double)serializer.Deserialize(stream)[0];
Assert.Equal(aDouble, actual);
}
public void can_round_trip_single_message()
{
var serializer = new XmlMessageSerializer();
var stream = new MemoryStream();
serializer.Serialize(sample, stream);
stream.Position = 0;
var actual = serializer.Deserialize(stream).ShouldBeOfType <Order>();
actual.OrderId.ShouldEqual(sample.OrderId);
}
static IConsumeContext <RoutingSlip> TranslateXmlBody(IReceiveContext context)
{
var serializer = new XmlMessageSerializer();
serializer.Deserialize(context);
IConsumeContext <RoutingSlip> routingSlipContext;
if (context.TryGetContext(out routingSlipContext))
{
return(routingSlipContext);
}
throw new InvalidOperationException("Unable to reprocess message as RoutingSlip");
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
dynamic response = new ExpandoObject();
XmlMessageSerializer serializer = new XmlMessageSerializer(new MessageMapper());
var message = serializer.Deserialize(new MemoryStream(e.Message.Body)).First();
response.Endpoint = bus.InputAddress.Queue;
response.Time = DateTime.UtcNow;
response.type = message.GetType().ToString();
response.body = message;
response.headers = e.Message.Headers;
_monitor.Invoke("MessageReceived", response);
}
protected void TestSerialization <T>(T message)
{
byte[] data;
var serializer = new XmlMessageSerializer();
_sourceUri = new Uri("loopback://localhost/source");
_responseUri = new Uri("loopback://localhost/response");
_faultUri = new Uri("loopback://localhost/fault");
_destinationUri = new Uri("loopback://localhost/destination");
_retryCount = 69;
OutboundMessage.Set(x =>
{
x.SetSourceAddress(_sourceUri);
x.SendResponseTo(_responseUri);
x.SendFaultTo(_faultUri);
x.SetDestinationAddress(_destinationUri);
x.SetRetryCount(_retryCount);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
object receivedMessage = serializer.Deserialize(input);
Assert.AreEqual(message, receivedMessage);
Assert.AreNotSame(message, receivedMessage);
Assert.AreEqual(_retryCount, CurrentMessage.Headers.RetryCount);
Assert.AreEqual(_sourceUri, CurrentMessage.Headers.SourceAddress);
Assert.AreEqual(_responseUri, CurrentMessage.Headers.ResponseAddress);
Assert.AreEqual(_faultUri, CurrentMessage.Headers.FaultAddress);
Assert.AreEqual(_destinationUri, CurrentMessage.Headers.DestinationAddress);
// Assert.AreEqual(message.GetType().ToMessageName(), CurrentMessage.Headers.MessageType);
}
}
public void Can_roundtrip()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[] { new Foo {
Name = "abc"
} }, stream);
stream.Position = 0;
var foo = (Foo)serializer.Deserialize(stream)[0];
Assert.Equal("abc", foo.Name);
Assert.Equal("ABC", foo.UName);
}
public void MoveErrorMessageToOriginQueue(QueueItem itm)
{
if (string.IsNullOrEmpty(itm.Id))
throw new ArgumentException("MessageId can not be null or empty");
if (itm.Queue.Type != QueueType.Error)
throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type);
var mgr = new ErrorManager();
// TODO:
// Check if Clustered Queue, due if Clustered && NonTransactional, then Error
//var deserializer = new XmlMessageSerializer();
XmlMessageSerializer _serializer = new XmlMessageSerializer();
using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? "")))
{
var rcx = ReceiveContext.FromBodyStream(stream);
_serializer.Deserialize(rcx);
//var query = rcx.DestinationAddress.Query;
//var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error";
//mgr.InputQueue = new EndpointAddress(errorQueue);
mgr.ReturnMessageToSourceQueue(itm.Id, rcx);
}
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
dynamic response = new ExpandoObject();
XmlMessageSerializer serializer = new XmlMessageSerializer(new MessageMapper());
var message = serializer.Deserialize(new MemoryStream(e.Message.Body)).First();
response.Endpoint = bus.InputAddress.Queue;
response.Time = DateTime.UtcNow;
response.type = message.GetType().ToString();
response.body = message;
response.headers = e.Message.Headers;
_monitor.Invoke("MessageReceived", response);
}
public void The_xml_message_serializer_should_rock_the_house()
{
byte[] serializedMessageData;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(x =>
{
x.SetSourceAddress("msmq://localhost/queue_name");
x.SetDestinationAddress("msmq://remotehost/queue_name");
x.SetResponseAddress("msmq://localhost/response_queue");
x.SetFaultAddress("msmq://localhost/fault_queue");
x.SetRetryCount(7);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, _message);
serializedMessageData = output.ToArray();
Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData));
}
using (MemoryStream input = new MemoryStream(serializedMessageData))
{
SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage;
Assert.AreEqual(_message, receivedMessage);
}
}
public void Just_how_fast_is_the_custom_xml_serializer()
{
var message = new SerializationTestMessage
{
DecimalValue = 123.45m,
LongValue = 098123213,
BoolValue = true,
ByteValue = 127,
IntValue = 123,
DateTimeValue = new DateTime(2008, 9, 8, 7, 6, 5, 4),
TimeSpanValue = 30.Seconds(),
GuidValue = Guid.NewGuid(),
StringValue = "Chris's Sample Code",
DoubleValue = 1823.172,
};
// var message = new PingMessage
// {
// CorrelationId = CombGuid.Generate()
// };
var serializer = new XmlMessageSerializer();
for (int i = 0; i < 10; i++)
{
byte[] data;
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
using (MemoryStream input = new MemoryStream(data))
{
// serializer.Deserialize(input);
}
}
Stopwatch timer = Stopwatch.StartNew();
const int iterations = 50000;
for (int i = 0; i < iterations; i++)
{
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
}
}
timer.Stop();
long perSecond = iterations*1000/timer.ElapsedMilliseconds;
var msg = string.Format("Serialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond);
Trace.WriteLine(msg);
byte[] sample;
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
sample = output.ToArray();
}
timer = Stopwatch.StartNew();
for (int i = 0; i < 50000; i++)
{
using (MemoryStream input = new MemoryStream(sample))
{
serializer.Deserialize(input);
}
}
timer.Stop();
perSecond = iterations*1000/timer.ElapsedMilliseconds;
msg = string.Format("Deserialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond);
Trace.WriteLine(msg);
}