public async Task C_ConnectEasyClientToHL7Interface()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent newSessionConnectedSignal = new AutoResetEvent(false);
AutoResetEvent welcomMessageReceived = new AutoResetEvent(false);
Assert.IsTrue(hl7Interface.Initialize());
Assert.IsTrue(hl7Interface.Start());
hl7Interface.HL7Server.NewSessionConnected += (hl7Session) =>
{
Assert.That(hl7Session is HL7Session);
Assert.That(hl7Session.Connected);
newSessionConnectedSignal.Set();
};
EasyClient client = new EasyClient();
client.Initialize(new TestProtoBaseDefaultTerminatorReceiverFilter(), (packageInfo) =>
{
//nothing
});
Assert.IsTrue(client.ConnectAsync(endPointA).Result);
Assert.That(client.IsConnected);
Assert.That(newSessionConnectedSignal.WaitOne());
await client.Close();
hl7Interface.Stop();
}
protected void CreateAndConfigureA(
bool ackRequired = true,
bool responseRequired = false,
int connectionTimeout = -1,
int ackTimeout = HL7ProtocolConfig.DefaultAcktimeout,
int responseTimeout = HL7ProtocolConfig.DefaultResponseTimeout)
{
hl7InterfaceA = new HL7InterfaceBase();
HL7ProtocolConfig hL7ProtocolConfigA = new HL7ProtocolConfig()
{
IsAckRequired = ackRequired,
IsResponseRequired = responseRequired,
ConnectionTimeout = connectionTimeout,
AckTimeout = ackTimeout
};
IServerConfig serverConfigA = new ServerConfig()
{
Ip = "127.0.0.1",
Port = 50060
};
hl7InterfaceA.Initialize(hL7ProtocolConfigA, serverConfigA);
}
public async Task O_HL7InterfaceSelfConnectShouldFail()
{
HL7InterfaceBase hl7InterfaceA = new HL7InterfaceBase();
HL7ProtocolBase protocolA = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = true,
IsResponseRequired = false
});
HL7Server serverA = new HL7Server();
Assert.IsTrue(serverA.Setup("127.0.0.1", 50060));
Assert.IsTrue(hl7InterfaceA.Initialize(serverA, protocolA));
Assert.That(hl7InterfaceA.Start());
hl7InterfaceA.NewSessionConnected += (e) =>
{
};
Assert.IsFalse(await hl7InterfaceA.ConnectAsync(endPointA));
hl7InterfaceA.Stop();
}
public async Task M_EasyCLientSendsCommandToHL7InterfaceWaitAckAndResponse()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent ackReceived = new AutoResetEvent(false);
AutoResetEvent commandResponseReceived = new AutoResetEvent(false);
HL7Server serverSide = new HL7Server();
Assert.IsTrue(serverSide.Setup("127.0.0.1", 50060));
Assert.IsTrue(hl7Interface.Initialize(serverSide, new HL7ProtocolBase(new HL7ProtocolConfig())));
Assert.That(hl7Interface.Start());
hl7Interface.NewRequestReceived += (s, e) =>
{
string response = MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode());
byte[] dataToSend = Encoding.ASCII.GetBytes(response);
s.Send(dataToSend, 0, dataToSend.Length);
};
PrepareForSpecimenRequest request = new PrepareForSpecimenRequest();
EasyClient client = new EasyClient();
client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
{
if (packageInfo.Request.IsAcknowledge)
{
Assert.That(packageInfo.Request is GeneralAcknowledgment);
Assert.That(HL7Parser.IsAckForRequest(request, packageInfo.Request));
ackReceived.Set();
}
else
{
Assert.IsTrue(packageInfo.Request is PrepareForSpecimenResponse);
commandResponseReceived.Set();
}
});
Assert.That(client.ConnectAsync(endPointA).Result);
byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(request.Encode()));
client.Send(bytesToSend);
Assert.That(ackReceived.WaitOne());
Assert.That(commandResponseReceived.WaitOne());
await client.Close();
serverSide.Stop();
hl7Interface.Stop();
}
public async Task I_HL7InterfaceSendsMessageToHL7ServerWaitAckAndResponseTest()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
HL7Server server = new HL7Server();
AutoResetEvent requestReceived = new AutoResetEvent(false);
HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = true,
IsResponseRequired = true,
AckTimeout = 10000,
ResponseTimeout = 50000
});
HL7Server serverSide = new HL7Server();
serverSide.Setup("127.0.0.1", 50060);
server.Setup("127.0.0.1", 2012);
server.Start();
hl7Interface.Initialize(serverSide, protocol);
hl7Interface.Start();
server.NewRequestReceived += (e, s) =>
{
Assert.That(s.Request is PrepareForSpecimenRequest);
requestReceived.Set();
Thread.Sleep(500);
byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode()));
e.Send(bytesToSend, 0, bytesToSend.Length);
};
bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012));
Assert.That(connected);
HL7Request req = await hl7Interface.SendHL7MessageAsync(new PrepareForSpecimenRequest());
Assert.IsNotNull(req);
Assert.That(req.Acknowledgment is GeneralAcknowledgment);
Assert.That(req.Acknowledgment.IsAckForRequest(req.Request));
Assert.That(req.Acknowledgment.GetValue("MSA-1") == "AA");
Assert.IsNotNull(req.Response);
Assert.That(req.Response.IsResponseForRequest(req.Request));
requestReceived.WaitOne();
server.Stop();
hl7Interface.Stop();
}
public async Task L_EasyClientSendsCommandToHL7InterfaceAndWaitAck()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent ackReceived = new AutoResetEvent(false);
AutoResetEvent commandResponseReceived = new AutoResetEvent(false);
HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = true,
IsResponseRequired = true
});
HL7Server serverSide = new HL7Server();
Assert.IsTrue(serverSide.Setup("127.0.0.1", 50060));
Assert.IsTrue(hl7Interface.Initialize(serverSide, protocol));
Assert.That(hl7Interface.Start());
PrepareForSpecimenRequest request = new PrepareForSpecimenRequest();
EasyClient client = new EasyClient();
client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
{
if (packageInfo.Request.IsAcknowledge)
{
Assert.That(packageInfo.Request is GeneralAcknowledgment);
Assert.That(HL7Parser.IsAckForRequest(request, packageInfo.Request));
ackReceived.Set();
}
else
{
Assert.Fail();
}
});
Assert.That(client.ConnectAsync(endPointA).Result);
byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(request.Encode()));
client.Send(bytesToSend);
Assert.That(ackReceived.WaitOne(timeout));
await client.Close();
hl7Interface.Stop();
}
public void A_InterfaceInitializeStartStop()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
Assert.That(hl7Interface.State == ServerState.NotInitialized);
Assert.IsTrue(hl7Interface.Initialize());
Assert.IsTrue(hl7Interface.Start());
Assert.IsTrue(hl7Interface.State == ServerState.Running);
hl7Interface.Stop();
Assert.That(hl7Interface.State == ServerState.NotStarted);
}
public async Task H_HL7InterfaceSendsMessageToHL7ServerWaitAck()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
HL7Server server = new HL7Server();
AutoResetEvent requestReceived = new AutoResetEvent(false);
HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = true,
IsResponseRequired = false
});
HL7Server serverSide = new HL7Server();
serverSide.Setup("127.0.0.1", 50060);
server.Setup("127.0.0.1", 2012);
server.Start();
hl7Interface.Initialize(serverSide, protocol);
hl7Interface.Start();
server.NewRequestReceived += (e, s) =>
{
Assert.That(s.Request is PrepareForSpecimenRequest);
requestReceived.Set();
};
bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012));
Assert.That(connected);
HL7Request req = await hl7Interface.SendHL7MessageAsync(new PrepareForSpecimenRequest());
Assert.IsNotNull(req);
Assert.That(req.Acknowledgment is GeneralAcknowledgment);
Assert.That(HL7Parser.IsAckForRequest(req.Request, req.Acknowledgment));
requestReceived.WaitOne();
server.Stop();
hl7Interface.Stop();
}
public async Task E_EasyClientSendsHL7MessageToHL7InterfaceAndReceivesAck()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent newRequestReceived = new AutoResetEvent(false);
Assert.IsTrue(hl7Interface.Initialize());
Assert.IsTrue(hl7Interface.Start());
PrepareForSpecimenRequest equipmentCommandRequest = new PrepareForSpecimenRequest();
hl7Interface.HL7Server.NewRequestReceived += (hl7Session, hl7Request) =>
{
Assert.That(hl7Request is HL7Request);
Assert.IsTrue(hl7Request.Request is PrepareForSpecimenRequest);
Assert.That(hl7Session.Connected);
};
EasyClient client = new EasyClient();
var tcs = new TaskCompletionSource <IHL7Message>();
client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
{
tcs.SetResult(packageInfo.Request);
});
Assert.That(await client.ConnectAsync(endPointA));
byte[] data = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(equipmentCommandRequest.Encode()));
client.Send(data);
var result = await tcs.Task;
Assert.IsTrue(result.IsAcknowledge);
Assert.IsTrue(HL7Parser.IsAckForRequest(equipmentCommandRequest, result));
await client.Close();
hl7Interface.Stop();
}
public async Task G_HL7InterfaceSendsMessageToHL7ServerNoAckNoResponse()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
HL7Server server = new HL7Server();
AutoResetEvent requestReceived = new AutoResetEvent(false);
HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = false,
IsResponseRequired = false
});
server.Setup("127.0.0.1", 50050);
server.Start();
HL7Server serverSide = new HL7Server();
serverSide.Setup("127.0.0.1", 50060);
hl7Interface.Initialize(serverSide, protocol);
hl7Interface.Start();
server.NewRequestReceived += (e, s) =>
{
Assert.That(s.Request is PrepareForSpecimenRequest);
requestReceived.Set();
};
bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50050));
Assert.That(connected);
await hl7Interface.SendHL7MessageAsync(new PrepareForSpecimenRequest());
requestReceived.WaitOne();
server.Stop();
hl7Interface.Stop();
}
public async Task F_HL7InterfaceReceivesHL7MessageSendsAResponseToEasyClient()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent newRequestReceived = new AutoResetEvent(false);
Assert.IsTrue(hl7Interface.Initialize());
Assert.IsTrue(hl7Interface.Start());
PrepareForSpecimenRequest equipmentCommandRequest = new PrepareForSpecimenRequest();
hl7Interface.HL7Server.NewSessionConnected += (hl7Session) =>
{
Assert.That(hl7Session.Connected);
string response = MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode());
byte[] dataToSend = Encoding.ASCII.GetBytes(response);
hl7Session.Send(dataToSend, 0, dataToSend.Length);
};
EasyClient client = new EasyClient();
var tcs = new TaskCompletionSource <IHL7Message>();
client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
{
tcs.SetResult(packageInfo.Request);
});
Assert.That(await client.ConnectAsync(endPointA));
var result = await tcs.Task;
Assert.IsTrue(result is PrepareForSpecimenResponse);
await client.Close();
hl7Interface.Stop();
}
public async Task B_ConnectHL7InterfaceToAppServer()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
HL7Server server = new HL7Server();
Assert.That(server.Setup("127.0.0.1", 2012));
Assert.That(server.Start());
Assert.That(hl7Interface.Initialize());
Assert.That(hl7Interface.Start());
bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012));
Assert.That(connected);
server.Stop();
hl7Interface.Stop();
}
public void D_HL7InterfaceSendsWelcomeOnEasyClientNewSessionConnected()
{
HL7InterfaceBase hl7Interface = new HL7InterfaceBase();
AutoResetEvent welcomMessageReceived = new AutoResetEvent(false);
Assert.IsTrue(hl7Interface.Initialize());
Assert.IsTrue(hl7Interface.Start());
hl7Interface.HL7Server.NewSessionConnected += (hl7Session) =>
{
Assert.That(hl7Session is HL7Session);
Assert.That(hl7Session.Connected);
byte[] data = Encoding.ASCII.GetBytes("|Welcome!||");
hl7Session.Send(data, 0, data.Length);
};
EasyClient client = new EasyClient();
client.Initialize(new TestProtoBaseBeginEndMarkReceiverFilter(), (packageInfo) =>
{
Assert.That(packageInfo.OriginalRequest.Equals("Welcome!"));
welcomMessageReceived.Set();
});
Assert.IsTrue(client.ConnectAsync(endPointA).Result);
Assert.That(client.IsConnected);
Assert.That(welcomMessageReceived.WaitOne());
hl7Interface.Stop();
}
public void Init()
{
State = new Ready();
HL7Interface = new HL7Interface.HL7InterfaceBase();
HL7Server server = new HL7Server();
HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
{
IsAckRequired = false,
IsResponseRequired = false
});
server.Setup("127.0.0.1", 2012);
server.Start();
HL7Server serverSide = new HL7Server();
serverSide.Setup("127.0.0.1", 50060);
HL7Interface.Initialize(serverSide, protocol);
HL7Interface.Start();
}
