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);
        }
Beispiel #3
0
        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));
        }
Beispiel #5
0
        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);
        }