public async Task Error_Callback_Should_Be_Executed_When_Serializer_Throws_An_Exception()
{
var serverErrorEvent = new AutoResetEvent(false);
var server = new TcpBinding(new IPEndPoint(IPAddress.Any, 1801), new ExceptionSerializer());
server.IoCompleted += (sender, e) => Debug.WriteLine(e.LastOperation);
server.Error += (sender, e) =>
{
serverErrorEvent.Set();
};
var result = server.ListenAsync();
Assert.IsTrue(result);
var client = new TcpBinding(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1801), new TestSerializer());
client.IoCompleted += (sender, e) => Debug.WriteLine(e.LastOperation);
await client.ConnectAsync();
await client.SendAsync(new TestPacket());
Assert.IsTrue(serverErrorEvent.WaitOne(TimeSpan.FromSeconds(3)));
}
public async Task Client_Should_Receive_Package_When_Server_Responds()
{
var serverReceivedEvent = new AutoResetEvent(false);
var clientReceivedEvent = new AutoResetEvent(false);
var server = new TcpBinding(new IPEndPoint(IPAddress.Any, 1800), new TestSerializer());
server.IoCompleted += (sender, e) => Debug.WriteLine(e.LastOperation);
server.PacketReceived += async(sender, e) =>
{
serverReceivedEvent.Set();
await e.Binding.SendAsync(e.Packet);
};
var result = server.ListenAsync();
Assert.IsTrue(result);
var client = new TcpBinding(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1800), new TestSerializer());
client.IoCompleted += (sender, e) => Debug.WriteLine(e.LastOperation);
client.PacketReceived += (sender, e) => clientReceivedEvent.Set();
await client.ConnectAsync();
await client.SendAsync(new TestPacket());
Assert.IsTrue(serverReceivedEvent.WaitOne(TimeSpan.FromSeconds(3)));
Assert.IsTrue(clientReceivedEvent.WaitOne(TimeSpan.FromSeconds(3)));
}
public async Task Meter_Should_Have_The_Address_Changed_When_Meter_Address_Is_Reconfigured()
{
var binding = new TcpBinding(new IPEndPoint(IPAddress.Parse(COLLECTOR_IP_ADDRESS), COLLECTOR_PORT), new MeterbusFrameSerializer());
var master = new MBusMaster(binding);
await master.SetMeterAddress(0x0a, 0x09);
}
public async Task Meter_Telemetry_Should_Be_Retrieved_When_Querying_The_Collector()
{
var binding = new TcpBinding(new IPEndPoint(IPAddress.Parse(COLLECTOR_IP_ADDRESS), COLLECTOR_PORT), new MeterbusFrameSerializer());
var master = new MBusMaster(binding);
var response = await master.RequestData(0x0a, TimeSpan.FromSeconds(TIMEOUT_IN_SECONDS)) as VariableDataPacket;
Assert.IsNotNull(response);
}
public async Task Meter_Scanner_Should_Find_Meter_When_Meter_Is_Connected_To_Collector()
{
var binding = new TcpBinding(new IPEndPoint(IPAddress.Parse(COLLECTOR_IP_ADDRESS), COLLECTOR_PORT), new MeterbusFrameSerializer());
var master = new MBusMaster(binding);
master.Meter += (sender, e) => Debug.WriteLine($"Found meter on address {e.Address.ToString("x2")}.");
await master.Scan(new byte[] { 0x0a }, TimeSpan.FromSeconds(100));
}
public async Task Meter_Should_Respond_When_Pinging_The_Meter()
{
var binding = new TcpBinding(new IPEndPoint(IPAddress.Parse(COLLECTOR_IP_ADDRESS), COLLECTOR_PORT), new MeterbusFrameSerializer());
var master = new MBusMaster(binding);
var result = await master.Ping(0x0a, TimeSpan.FromSeconds(TIMEOUT_IN_SECONDS));
Assert.IsTrue(result);
}
protected virtual async Task <IMqttClient> GetClientAsync()
{
var binding = new TcpBinding();
var initializer = new MqttClientFactory(IPAddress.Loopback.ToString(), binding);
if (Configuration == null)
{
LoadConfiguration();
}
return(await initializer.CreateClientAsync(Configuration));
}
public async Task Meter_Should_Respond_With_Ack_When_Sending_SND_NKE()
{
var resetEvent = new AutoResetEvent(false);
var endpoint = new TcpBinding(new IPEndPoint(IPAddress.Parse(COLLECTOR_IP_ADDRESS), COLLECTOR_PORT), new MeterbusFrameSerializer());
endpoint.PacketReceived += (sender, e) => resetEvent.Set();
await endpoint.ConnectAsync();
await endpoint.SendAsync(new ShortFrame((byte)ControlMask.SND_NKE, 0x0a));
Assert.IsTrue(resetEvent.WaitOne(TimeSpan.FromSeconds(TIMEOUT_IN_SECONDS)));
await endpoint.DisconnectAsync();
}
public async Task when_initializing_client_then_succeeds()
{
var port = new Random().Next(IPEndPoint.MinPort, IPEndPoint.MaxPort);
var listener = new TcpListener(IPAddress.Loopback, port);
listener.Start();
var configuration = new MqttConfiguration {
BufferSize = 131072,
Port = port
};
var binding = new TcpBinding();
var initializer = new MqttClientFactory(IPAddress.Loopback.ToString(), binding);
var client = await initializer.CreateClientAsync(configuration);
Assert.NotNull(client);
listener.Stop();
}
public I CreateChannel <I>()
{
ChannelFactory <I> channelfactory = null;
string prefix = string.Empty;
Binding binding = null;
bool useSSL = SecurityMode == ServiceSecurityMode.BasicSSL;
switch (Type)
{
case ServiceType.HTTP:
prefix = useSSL ? "https" : "http";
if (useSSL)
{
binding = new HttpBinding
{
Security =
{
Mode = BasicHttpSecurityMode.Transport,
Transport =
{
ClientCredentialType = HttpClientCredentialType.None,
Realm = string.Empty,
ProxyCredentialType = HttpProxyCredentialType.None
}
}
};
}
else
{
binding = new HttpBinding();
}
break;
case ServiceType.WSHTTP:
prefix = useSSL ? "https" : "http";
if (useSSL)
{
binding = new WsHttpBinding
{
Security =
{
Mode = System.ServiceModel.SecurityMode.Transport,
Transport =
{
ClientCredentialType = HttpClientCredentialType.None,
Realm = string.Empty,
ProxyCredentialType = HttpProxyCredentialType.None
}
}
};
}
else
{
binding = new WsHttpBinding();
}
break;
case ServiceType.TCP:
binding = new TcpBinding();
prefix = "net.tcp";
break;
case ServiceType.REST:
if (useSSL)
{
binding = new RestBinding
{
Security =
{
Mode = WebHttpSecurityMode.Transport,
Transport =
{
ClientCredentialType = HttpClientCredentialType.None,
Realm = string.Empty,
ProxyCredentialType = HttpProxyCredentialType.None
}
}
};
}
else
{
binding = new RestBinding();
}
prefix = useSSL ? "https" : "http";
break;
}
if (binding == null)
{
throw new NullReferenceException("No appropriate binding found for type:" + Type);
}
_address = String.Format(UriFormat, prefix, ServerName, Port, ServiceName);
CurrentContext.Default.Log.SvcInfo(String.Format("Creating WCF Client at {0}", _address));
channelfactory = new ChannelFactory <I>(binding, new EndpointAddress(_address));
if (binding is RestBinding)
{
channelfactory.Endpoint.Behaviors.Add(new WebHttpBehavior());
}
var channel = channelfactory.CreateChannel();
channelfactory.Endpoint.AttachDataResolver();
return(channel);
}
