public void Setting_up_interface_with_IObservables_with_invalid_classes_should_throw()
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
var client = new ReactiveMessageClient <IMessageHandlerWithInvalidObservable>(framedClient, serializer.Object);
});
}
public void Setting_up_interface_with_property_other_than_IObservable_properties_should_throw()
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
var client = new ReactiveMessageClient <IMessageHandlerWithMethod>(framedClient, serializer.Object);
});
}
public void Receiving_packet_should_be_properly_deserialized()
{
var received = false;
var serializer = new ProtoBufStacksSerializer();
var packet = new MemoryStream();
serializer.Serialize(CreateSampleTestData(), packet);
var client = new ReactiveMessageClient <ITestMessageHandler>(framedClient, serializer);
client.Packets.TestPackets.Subscribe(p =>
{
Assert.Equal(42, p.Foo);
Assert.Equal(Math.PI, p.Bar);
Assert.Equal((decimal)Math.PI, p.Zar);
Assert.Equal("Foo bar test", p.Sar);
received = true;
});
rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes((int)packet.Length + 8)));
rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes(3)));
rawClientReceived.OnNext(new ArraySegment <byte>(packet.GetBuffer(), 0, (int)packet.Length));
Assert.True(received);
}
public void When_more_packets_are_registered_only_valid_observer_should_be_notified()
{
var validReceived = false;
var invalidReceived = false;
var serializer = new ProtoBufStacksSerializer();
var packet = new MemoryStream();
serializer.Serialize(new TestData2 {
Bar = 6
}, packet);
var client = new ReactiveMessageClient <IComplexTestMessageHandler>(framedClient, serializer);
client.Packets.TestPackets.Subscribe(p =>
{
invalidReceived = true;
});
client.Packets.TestPackets2.Subscribe(p =>
{
validReceived = true;
});
rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes((int)packet.Length + 8)));
rawClientReceived.OnNext(new ArraySegment <byte>(BitConverter.GetBytes(1)));
rawClientReceived.OnNext(new ArraySegment <byte>(packet.GetBuffer(), 0, (int)packet.Length));
Assert.True(validReceived);
Assert.False(invalidReceived);
}
public void Run(int serverPort)
{
client = new ReactiveMessageClient <IClientPacketHandler>(
new FramedClient(new SocketClient()),
new ProtoBufStacksSerializer());
client.PreLoadTypesFromAssemblyOfType <Price>();
priceObserver = client.Packets.Price.Subscribe(p =>
{
Console.WriteLine("Price received: {0} - {1:F5} / {2:F5}",
p.Symbol, p.Bid, p.Offer);
});
client.Connect(new IPEndPoint(IPAddress.Loopback, serverPort))
.Subscribe(async _ =>
{
await Task.Delay(2000);
client.Send(new RegisterSymbolRequest()
{
Symbol = "EURUSD", Register = true
});
client.Send(new RegisterSymbolRequest()
{
Symbol = "GBPLN", Register = true
});
});
}
public void Subject_should_not_be_exposed_directly()
{
var client = new ReactiveMessageClient <ITestMessageHandler>(framedClient, serializer.Object);
var observable = client.Packets.TestPackets;
Assert.False(observable.GetType().GetGenericTypeDefinition() == typeof(Subject <>));
}
public void Run()
{
ReactiveMessageClient <IServerPacketHandler> client = null;
service = new MarketService();
server = new SocketServer(new IPEndPoint(IPAddress.Loopback, 0));
server.Connected.Subscribe(c =>
{
client = new ReactiveMessageClient <IServerPacketHandler>(
new FramedClient(c),
new ProtoBufStacksSerializer());
client.PreLoadTypesFromAssemblyOfType <Price>();
// Here is the subscription to all the packets.
// `.Packets` is an implementation of interface
// given when message client was defined, so
// every packet has a strongly typed `IObservable<TPacket>`
// to subscribe to.
client.Packets.RegisterSymbol.Subscribe(req =>
{
if (req.Register)
{
service.RegisterSymbol(req.Symbol);
}
else
{
service.UnregisterSymbol(req.Symbol);
}
});
});
// Service will only report registered price changes.
// In this sample, this observer should not run
// for 4 seconds after application start.
service.PricesChanged.Subscribe(prices =>
{
Console.WriteLine("Services reported that prices changed");
// Send new prices to client.
foreach (var p in prices)
{
if (client != null)
{
client.Send(p);
}
}
});
server.Start();
this.ServerPort = server.BindEndPoint.Port;
}
public void Run()
{
ReactiveMessageClient<IServerPacketHandler> client = null;
service = new MarketService();
server = new SocketServer(new IPEndPoint(IPAddress.Loopback, 0));
server.Connected.Subscribe(c =>
{
client = new ReactiveMessageClient<IServerPacketHandler>(
new FramedClient(c),
new ProtoBufStacksSerializer());
client.PreLoadTypesFromAssemblyOfType<Price>();
// Here is the subscription to all the packets.
// `.Packets` is an implementation of interface
// given when message client was defined, so
// every packet has a strongly typed `IObservable<TPacket>`
// to subscribe to.
client.Packets.RegisterSymbol.Subscribe(req =>
{
if (req.Register)
service.RegisterSymbol(req.Symbol);
else
service.UnregisterSymbol(req.Symbol);
});
});
// Service will only report registered price changes.
// In this sample, this observer should not run
// for 4 seconds after application start.
service.PricesChanged.Subscribe(prices =>
{
Console.WriteLine("Services reported that prices changed");
// Send new prices to client.
foreach (var p in prices)
{
if (client != null)
client.Send(p);
}
});
server.Start();
this.ServerPort = server.BindEndPoint.Port;
}
public void Receiving_packet_should_be_notified_properly()
{
bool received = false;
serializer.Setup(s => s.Deserialize <TestData>(It.IsAny <MemoryStream>())).Returns(new TestData());
var c = new ReactiveMessageClient <ITestMessageHandler>(framedClient, serializer.Object);
c.Packets.TestPackets.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment <byte>(new byte[] { 12, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void Using_model_builder_should_allow_to_fix_missing_packets()
{
bool received = false;
var client = new ReactiveMessageClient <IMessageHandlerWithInvalidObservable>(framedClient, serializer.Object,
mb =>
{
mb.Packet(i => i.TestPackets3).HasId(3);
});
client.Packets.TestPackets3.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment <byte>(new byte[] { 12, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void Using_model_builder_it_should_be_possible_to_override_packet_id()
{
bool received = false;
serializer.Setup(s => s.Deserialize <TestData>(It.IsAny <MemoryStream>())).Returns(new TestData());
var c = new ReactiveMessageClient <ITestMessageHandler>(framedClient, serializer.Object,
mb =>
{
mb.Packet(t => t.TestPackets).HasId(2);
});
c.Packets.TestPackets.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment <byte>(new byte[] { 12, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void Run(int serverPort)
{
client = new ReactiveMessageClient<IClientPacketHandler>(
new FramedClient(new SocketClient()),
new ProtoBufStacksSerializer());
client.PreLoadTypesFromAssemblyOfType<Price>();
priceObserver = client.Packets.Price.Subscribe(p =>
{
Console.WriteLine("Price received: {0} - {1:F5} / {2:F5}",
p.Symbol, p.Bid, p.Offer);
});
client.Connect(new IPEndPoint(IPAddress.Loopback, serverPort))
.Subscribe(async _ =>
{
await Task.Delay(2000);
client.Send(new RegisterSymbolRequest() { Symbol = "EURUSD", Register = true });
client.Send(new RegisterSymbolRequest() { Symbol = "GBPLN", Register = true });
});
}
public void Setting_up_interface_with_IObservables_with_invalid_classes_should_throw()
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
var client = new ReactiveMessageClient<IMessageHandlerWithInvalidObservable>(framedClient, serializer.Object);
});
}
public void Receiving_packet_should_be_notified_properly()
{
bool received = false;
serializer.Setup(s => s.Deserialize<TestData>(It.IsAny<MemoryStream>())).Returns(new TestData());
var c = new ReactiveMessageClient<ITestMessageHandler>(framedClient, serializer.Object);
c.Packets.TestPackets.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment<byte>(new byte[] { 12, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void Subject_should_not_be_exposed_directly()
{
var client = new ReactiveMessageClient<ITestMessageHandler>(framedClient, serializer.Object);
var observable = client.Packets.TestPackets;
Assert.False(observable.GetType().GetGenericTypeDefinition() == typeof(Subject<>));
}
public void Receiving_packet_should_be_properly_deserialized()
{
var received = false;
var serializer = new ProtoBufStacksSerializer();
var packet = new MemoryStream();
serializer.Serialize(CreateSampleTestData(), packet);
var client = new ReactiveMessageClient<ITestMessageHandler>(framedClient, serializer);
client.Packets.TestPackets.Subscribe(p =>
{
Assert.Equal(42, p.Foo);
Assert.Equal(Math.PI, p.Bar);
Assert.Equal((decimal)Math.PI, p.Zar);
Assert.Equal("Foo bar test", p.Sar);
received = true;
});
rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes((int)packet.Length + 8)));
rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes(3)));
rawClientReceived.OnNext(new ArraySegment<byte>(packet.GetBuffer(), 0, (int)packet.Length));
Assert.True(received);
}
public void Using_model_builder_it_should_be_possible_to_override_packet_id()
{
bool received = false;
serializer.Setup(s => s.Deserialize<TestData>(It.IsAny<MemoryStream>())).Returns(new TestData());
var c = new ReactiveMessageClient<ITestMessageHandler>(framedClient, serializer.Object,
mb =>
{
mb.Packet(t => t.TestPackets).HasId(2);
});
c.Packets.TestPackets.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment<byte>(new byte[] { 12, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void Using_model_builder_should_allow_to_fix_missing_packets()
{
bool received = false;
var client = new ReactiveMessageClient<IMessageHandlerWithInvalidObservable>(framedClient, serializer.Object,
mb =>
{
mb.Packet(i => i.TestPackets3).HasId(3);
});
client.Packets.TestPackets3.Subscribe(p =>
{
received = true;
});
rawClientReceived.OnNext(new ArraySegment<byte>(new byte[] { 12, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0 }));
Assert.True(received);
}
public void When_more_packets_are_registered_only_valid_observer_should_be_notified()
{
var validReceived = false;
var invalidReceived = false;
var serializer = new ProtoBufStacksSerializer();
var packet = new MemoryStream();
serializer.Serialize(new TestData2 { Bar = 6 }, packet);
var client = new ReactiveMessageClient<IComplexTestMessageHandler>(framedClient, serializer);
client.Packets.TestPackets.Subscribe(p =>
{
invalidReceived = true;
});
client.Packets.TestPackets2.Subscribe(p =>
{
validReceived = true;
});
rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes((int)packet.Length + 8)));
rawClientReceived.OnNext(new ArraySegment<byte>(BitConverter.GetBytes(1)));
rawClientReceived.OnNext(new ArraySegment<byte>(packet.GetBuffer(), 0, (int)packet.Length));
Assert.True(validReceived);
Assert.False(invalidReceived);
}
public void Setting_up_interface_with_property_other_than_IObservable_properties_should_throw()
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
var client = new ReactiveMessageClient<IMessageHandlerWithMethod>(framedClient, serializer.Object);
});
}
