Task <TResponse> ICoreLink.Request <TRequest, TResponse>(IConversation <TRequest, TResponse> conversation, int timeoutMs)
{
return(Task <TResponse> .Factory.StartNew(() =>
{
TRequest request = conversation.RequestData;
if (Fail)
{
throw new RemoteCoreException(m_errorMessage);
}
StateType resultState = StateType.Empty;
var commandRequest = request as CommandRequest;
if (commandRequest != null)
{
switch (commandRequest.Command)
{
case CommandType.Load:
resultState = StateType.Paused;
break;
case CommandType.Run:
resultState = StateType.Running;
break;
case CommandType.Pause:
resultState = StateType.Paused;
break;
case CommandType.Clear:
resultState = StateType.Empty;
break;
case CommandType.Shutdown:
resultState = StateType.ShuttingDown;
break;
default:
throw new ArgumentOutOfRangeException();
}
m_lastState = resultState;
}
var getStateRequest = request as GetStateRequest;
if (getStateRequest != null)
{
resultState = m_lastState;
}
ResponseMessage responseMessage = StateResponseBuilder.Build(resultState);
return responseMessage.GetResponse(new TResponse());
}));
}
public void GetsAsyncConversationResult()
{
var conversation = new CommandConversation(CommandType.Run);
ResponseMessage responseMessage = StateResponseBuilder.Build(StateType.Running);
ICoreLink coreLink = GenerateCoreLink(responseMessage);
Task <StateResponse> futureResponse = coreLink.Request(conversation, WaitMs);
StateResponse receivedResponse = ReadResponse(futureResponse);
Assert.Equal(StateType.Running, receivedResponse.State);
}
public void ParsesResponseMessage()
{
ResponseMessage responseMessage = StateResponseBuilder.Build(StateType.Running);
var parser = new CoreResponseParser();
byte[] buffer = BufferConverter.Convert(responseMessage.ByteBuffer);
var response = parser.Parse <ResponseMessage>(buffer);
Assert.Equal(Response.StateResponse, response.ResponseType);
StateType state = response.GetResponse(new StateResponse()).State;
Assert.Equal(StateType.Running, state);
}
public async Task TimesOut()
{
var conv = new CommandConversation(CommandType.Run);
var response = StateResponseBuilder.Build(StateType.Paused);
var converseClientMock = new Mock <IConverseFlatBuffersClient>();
converseClientMock.Setup(client =>
client.SendQuery <CommandRequest, ResponseMessage>(Conversation.Handler, It.IsAny <CommandRequest>()))
.Callback(() => Thread.Sleep(WaitMs * 2))
.Returns(response);
IConverseFlatBuffersClient converseClient = converseClientMock.Object;
var coreLink = new CoreLink(converseClient);
await Assert.ThrowsAsync <TaskTimeoutException <StateResponse> >(() => coreLink.Request(conv, WaitMs));
}
public ConductorTests()
{
m_coreProcessMock = new Mock <ICoreProcess>();
m_coreProcessMock.Setup(process => process.EndPoint).Returns(new EndPoint("localhost", 42));
var coreLinkMock = new Mock <ICoreLink>();
m_coreProxyMock = new Mock <ICoreProxy>();
m_coreProxyMock.Setup(coreProxy => coreProxy.LoadBlueprintAsync(It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Raises(coreProxy => coreProxy.StateChanged += null,
new StateChangedEventArgs(CoreState.Empty, CoreState.Paused));
m_coreProxyMock.Setup(coreProxy => coreProxy.RunAsync(It.IsAny <uint>(), It.IsAny <bool>()))
.Returns(Task.CompletedTask)
.Raises(coreProxy => coreProxy.StateChanged += null,
new StateChangedEventArgs(CoreState.Paused, CoreState.Running));
m_coreProxyMock.Setup(coreProxy => coreProxy.PauseAsync())
.Returns(Task.CompletedTask)
.Raises(coreProxy => coreProxy.StateChanged += null,
new StateChangedEventArgs(CoreState.Running, CoreState.Paused));
m_coreProxyMock.Setup(coreProxy => coreProxy.ClearAsync())
.Returns(Task.CompletedTask)
.Raises(coreProxy => coreProxy.StateChanged += null,
new StateChangedEventArgs(CoreState.Paused, CoreState.Empty));
m_coreProxyMock.Setup(coreProxy => coreProxy.ShutdownAsync())
.Returns(Task.CompletedTask)
.Raises(coreProxy => coreProxy.StateChanged += null,
new StateChangedEventArgs(CoreState.Empty, CoreState.ShuttingDown));
var coreProcessFactoryMock = new Mock <ICoreProcessFactory>();
coreProcessFactoryMock.Setup(factory => factory.Create(m_coreProcessParams.CoreProcessParams))
.Returns(m_coreProcessMock.Object);
var coreLinkFactoryMock = new Mock <ICoreLinkFactory>();
coreLinkFactoryMock.Setup(factory => factory.Create(It.IsAny <EndPoint>()))
.Returns(coreLinkMock.Object);
var coreControllerFactoryMock = new Mock <ICoreControllerFactory>();
coreControllerFactoryMock.Setup(factory => factory.Create(It.IsAny <ICoreLink>())).Returns(new CoreController(coreLinkMock.Object));
var response = StateResponseBuilder.Build(StateType.ShuttingDown);
var stateResponse = response.GetResponse(new StateResponse());
coreLinkMock.Setup(link => link.Request(It.IsAny <CommandConversation>(), It.IsAny <int>())).Returns(() =>
{
return(Task <StateResponse> .Factory.StartNew(
() => stateResponse));
});
var coreProxyFactoryMock = new Mock <ICoreProxyFactory>();
coreProxyFactoryMock.Setup(factory => factory.Create(It.IsAny <ICoreController>(), It.IsAny <IModelUpdater>()))
.Returns(m_coreProxyMock.Object);
m_conductor = new Conductor(coreProcessFactoryMock.Object, coreLinkFactoryMock.Object,
coreControllerFactoryMock.Object, coreProxyFactoryMock.Object, new Mock <IModelUpdaterFactory>().Object,
new Mock <IModelProviderFactory>().Object, new Mock <ICharmdRunner>().Object);
}
public void WritesReadsStateResponse()
{
var message = StateResponseBuilder.Build(StateType.ShuttingDown);
Assert.Equal(StateType.ShuttingDown, message.GetResponse(new StateResponse()).State);
}
