public void Adding_then_removing_will_result_in_no_subscriptions()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var msg = new Message();
serializer.Serialize(new object[]{new AddSubscription
{
Endpoint = transactionalTestQueueEndpoint,
Type = typeof(TestMessage).FullName,
}}, msg.BodyStream);
msg.Extension = Guid.NewGuid().ToByteArray();
queue.OpenSiblngQueue(SubQueue.Subscriptions, QueueAccessMode.Send).Send(msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
testQueueEndPoint.Uri,
new EndpointRouter(),
new FlatQueueStrategy(new EndpointRouter(),testQueueEndPoint.Uri));
subscriptionStorage.Initialize();
subscriptionStorage.RemoveSubscription(typeof(TestMessage).FullName, transactionalTestQueueEndpoint.Uri.ToString());
var uris = subscriptionStorage
.GetSubscriptionsFor(typeof(TestMessage));
Assert.Equal(0, uris.Count());
}
public static void Test(ITransport t, IQueueStrategy strategy,
Endpoint queueEndpoint, Action<Message> send, Func<MessageEnumerator>
enumer)
{
Guid id = Guid.NewGuid();
var serializer = new XmlMessageSerializer(new
DefaultReflection(), new DefaultKernel());
var subscriptionStorage = new MsmqSubscriptionStorage(new
DefaultReflection(),
serializer,
queueEndpoint.Uri,
new
EndpointRouter(),
strategy);
subscriptionStorage.Initialize();
var wait = new ManualResetEvent(false);
subscriptionStorage.SubscriptionChanged += () => wait.Set();
t.AdministrativeMessageArrived +=
subscriptionStorage.HandleAdministrativeMessage;
Message msg = new MessageBuilder
(serializer).GenerateMsmqMessageFromMessageBatch(new
AddInstanceSubscription
{
Endpoint = queueEndpoint.Uri.ToString(),
InstanceSubscriptionKey = id,
Type = typeof (TestMessage2).FullName,
});
send(msg);
wait.WaitOne();
msg = new MessageBuilder
(serializer).GenerateMsmqMessageFromMessageBatch(new
RemoveInstanceSubscription
{
Endpoint = queueEndpoint.Uri.ToString(),
InstanceSubscriptionKey = id,
Type = typeof (TestMessage2).FullName,
});
wait.Reset();
send(msg);
wait.WaitOne();
IEnumerable<Uri> uris = subscriptionStorage
.GetSubscriptionsFor(typeof (TestMessage2));
Assert.Equal(0, uris.Count());
int count = 0;
MessageEnumerator copy = enumer();
while (copy.MoveNext()) count++;
Assert.Equal(0, count);
}
public void Can_read_subscription_from_queue()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var msg = new Message();
serializer.Serialize(new object[]{new AddSubscription
{
Endpoint = TransactionalTestQueueUri.ToString(),
Type = typeof(TestMessage).FullName,
}}, msg.BodyStream);
queue.Send(msg, MessageQueueTransactionType.None);
msg = queue.Peek();
queue.MoveToSubQueue("subscriptions", msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
TestQueueUri,
new SubQueueStrategy());
subscriptionStorage.Initialize();
var uri = subscriptionStorage
.GetSubscriptionsFor(typeof(TestMessage))
.Single();
Assert.Equal(TransactionalTestQueueUri, uri);
}
public void Adding_then_removing_will_result_in_no_subscriptions()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var msg = new Message();
serializer.Serialize(new object[]{new AddSubscription
{
Endpoint = TransactionalTestQueueUri,
Type = typeof(TestMessage).FullName,
}}, msg.BodyStream);
msg.Extension = Guid.NewGuid().ToByteArray();
queue.Send(msg, MessageQueueTransactionType.None);
msg = queue.Peek(TimeSpan.FromSeconds(30));
queue.MoveToSubQueue("subscriptions",msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
TestQueueUri.Uri,
new EndpointRouter(),
new SubQueueStrategy());
subscriptionStorage.Initialize();
subscriptionStorage.RemoveSubscription(typeof(TestMessage).FullName, TransactionalTestQueueUri.Uri.ToString());
var uris = subscriptionStorage
.GetSubscriptionsFor(typeof (TestMessage));
Assert.Equal(0, uris.Count());
}
public void Adding_then_removing_will_result_in_no_subscriptions()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var msg = new Message();
serializer.Serialize(new object[]{new AddSubscription
{
Endpoint = TransactionalTestQueueUri.ToString(),
Type = typeof(TestMessage).FullName,
}}, msg.BodyStream);
queue.Send(msg, MessageQueueTransactionType.None);
msg = queue.Peek();
queue.MoveToSubQueue("subscriptions",msg);
var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(),
serializer,
TestQueueUri,
new SubQueueStrategy());
subscriptionStorage.Initialize();
subscriptionStorage.RemoveSubscription(typeof(TestMessage).FullName, TransactionalTestQueueUri.ToString());
var uris = subscriptionStorage
.GetSubscriptionsFor(typeof (TestMessage));
Assert.Equal(0, uris.Count());
}
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_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 Can_serialize_and_deserialize_byte_array()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
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 Can_serialize_and_deserialize_primitive()
{
long ticks = DateTime.Now.Ticks;
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
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_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 Roundtrip_with_datetime_should_preserved_DateTimeKind(DateTimeKind kind)
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
var date = new DateTime(DateTime.Now.Ticks, kind);
serializer.Serialize(new object[] { new Bar { Date = date } }, stream);
stream.Position = 0;
var bar = (Bar)serializer.Deserialize(stream)[0];
Assert.Equal(date, bar.Date);
Assert.Equal(kind, bar.Date.Kind);
}
public void Can_serialize_and_deserialize_array()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new object[]
{
new ClassWithObjectArray
{
Items = new object[] {new OrderLine {Product = "ayende"}}
}
}, stream);
stream.Position = 0;
var actual = (ClassWithObjectArray) serializer.Deserialize(stream)[0];
Assert.Equal("ayende", ((OrderLine)actual.Items[0]).Product);
}
public UsingRhinoQueuesTransport()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
messageSerializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
transport = new RhinoQueuesTransport(
new Uri("rhino.queues://localhost:23456/q"),
new EndpointRouter(),
messageSerializer,
1,
"test.esent",
IsolationLevel.Serializable,
5
);
transport.Start();
}
public void Can_use_dictionaries_initialized()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[] { new ItemWithInitDictionary { Name = "abc", Arguments = new Dictionary<string, string>
{
{"abc","cdef"}
}} }, stream);
stream.Position = 0;
var foo = (ItemWithInitDictionary)serializer.Deserialize(stream)[0];
Assert.Equal("abc", foo.Name);
Assert.Equal("cdef", foo.Arguments["abc"]);
}
public UsingRhinoQueuesTransport()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
messageSerializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
transport = new RhinoQueuesTransport(
new Uri("rhino.queues://localhost:23456/q"),
new EndpointRouter(),
messageSerializer,
1,
"test.esent",
IsolationLevel.Serializable,
5,
false,
new RhinoQueuesMessageBuilder(messageSerializer)
);
transport.Start();
}
public void Can_deserialize_complex_object_graph()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var stream = new MemoryStream();
serializer.Serialize(new[] {sample}, stream);
stream.Position = 0;
var order = (Order) serializer.Deserialize(stream)[0];
Assert.Equal(sample.Url, order.Url);
Assert.Equal(sample.At, order.At);
Assert.Equal(sample.Count, order.Count);
Assert.Equal(sample.OrderId, order.OrderId);
Assert.Equal(sample.TimeToDelivery, order.TimeToDelivery);
Assert.Equal(2, order.OrderLines.Length);
Assert.Equal(sample.OrderLines[0].Product, order.OrderLines[0].Product);
Assert.Equal(sample.OrderLines[1].Product, order.OrderLines[1].Product);
}
public WhenReceivingTimedMessage()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
var serviceLocator = new CastleServiceLocator(new WindsorContainer());
messageSerializer = new XmlMessageSerializer(new DefaultReflection(),
serviceLocator);
transport = new RhinoFilesTransport(
new Uri("file://localhost/q"),
new EndpointRouter(),
messageSerializer,
1,
"test.esent",
IsolationLevel.Serializable,
5,
false,
new RhinoFilesMessageBuilder(messageSerializer, serviceLocator),
new QueueManagerConfiguration()
);
transport.Start();
}
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 DefaultKernel());
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 Trying_to_send_more_than_256_objects_will_fail()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
Assert.Throws<UnboundedResultSetException>(() => serializer.Serialize(new object[257], new MemoryStream()));
}
public void Can_serialize_and_deserialize_DateTimeOffset()
{
var value = DateTimeOffset.Now;
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
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 Can_serialize_and_deserialize_array_with_null_item()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(),
new CastleServiceLocator(new WindsorContainer()));
var stream = new MemoryStream();
serializer.Serialize(new object[]
{
new ClassWithObjectArray
{
Items = new object[] {new OrderLine {Product = "ayende"}, null, new OrderLine {Product = "rahien"}}
}
}, stream);
stream.Position = 0;
var actual = (ClassWithObjectArray)serializer.Deserialize(stream)[0];
Assert.Equal(3, actual.Items.Length);
Assert.Equal("ayende", ((OrderLine)actual.Items[0]).Product);
Assert.Null(actual.Items[1]);
Assert.Equal("rahien", ((OrderLine)actual.Items[2]).Product);
}
public void Trying_to_send_message_with_list_of_more_than_256_items_will_fail()
{
var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel());
var order = new Order
{
OrderLines = new OrderLine[257]
};
for (int i = 0; i < 257; i++)
{
order.OrderLines[i] = new OrderLine();
}
try
{
serializer.Serialize(new[] {order}, new MemoryStream());
Assert.False(true, "should throw");
}
catch (SerializationException e)
{
Assert.IsType<UnboundedResultSetException>(e.InnerException);
}
}
public ThrowingSerializer(XmlMessageSerializer serializer)
{
this.serializer = serializer;
}
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);
}
