Example #1
0
        public string ServiceCall(bool throwException)
        {
            ServiceParameterPassed            startMessage = new ServiceParameterPassed(throwException);
            MessageGateResult <ServiceResult> result       = gate.SendAndAwait(startMessage, OnMessage);

            return(result.Result == MessageGateResultKind.Success ? result.EndMessage.Result : "Exception");
        }
Example #2
0
        public void CancelGateWithCancelToken()
        {
            using CancellationTokenSource source = new(500);
            TestMessage startMessage = new();
            MessageGate <TestMessage, OtherMessage> gate = new();

            MessageGateResult <OtherMessage> result = gate.SendAndAwait(startMessage, m => {}, cancellationToken: source.Token);

            source.IsCancellationRequested.Should().BeTrue("something went wrong otherwise.");
            result.Result.Should().Be(MessageGateResultKind.Canceled);
        }
Example #3
0
        public void ReturnExceptionMessageIfUnsuccessful()
        {
            TestMessage startMessage = new();
            MessageGate <TestMessage, OtherMessage> gate = new();
            ExceptionMessage exception = null;

            using Timer timer = new(state =>
            {
                exception = new ExceptionMessage("Error", startMessage, new HelloAgent(Substitute.For <IMessageBoard>()));
                gate.Check(exception);
            }, null, 200,
                                    Timeout.Infinite);
            MessageGateResult <OtherMessage> result = gate.SendAndAwait(startMessage, m => {});

            result.Result.Should().Be(MessageGateResultKind.Exception);
            result.Exceptions.Should().ContainSingle(message => ReferenceEquals(message, exception));
        }
Example #4
0
        public void ReturnEndMessageIfSuccess()
        {
            TestMessage startMessage = new();
            MessageGate <TestMessage, OtherMessage> gate = new();
            OtherMessage endMessage = null;

            using Timer timer = new(state =>
            {
                endMessage = new OtherMessage(startMessage);
                gate.Check(endMessage);
            }, null, 200,
                                    Timeout.Infinite);
            MessageGateResult <OtherMessage> result = gate.SendAndAwait(startMessage, m => {});

            result.Result.Should().Be(MessageGateResultKind.Success);
            result.EndMessage.Should().BeSameAs(endMessage);
        }
Example #5
0
        public void TimeoutIfExceptionMessageIsOutsideOfMessageDomain()
        {
            TestMessage startMessage = new();
            MessageGate <TestMessage, OtherMessage> gate = new();
            bool executed = false;

            using Timer timer = new(state =>
            {
                ExceptionMessage exception = new("Error", Array.Empty <Message>(), new HelloAgent(Substitute.For <IMessageBoard>()));
                MessageDomain.CreateNewDomainsFor(exception);
                gate.Check(exception);
                executed = true;
            }, null, 200,
                                    Timeout.Infinite);
            MessageGateResult <OtherMessage> result = gate.SendAndAwait(startMessage, m => {}, 500);

            executed.Should().BeTrue("otherwise there is a timing issue.");
            result.Result.Should().Be(MessageGateResultKind.Timeout);
        }
Example #6
0
        public void TimeoutIfEndMessageIsOutsideOfMessageDomain()
        {
            TestMessage startMessage = new();
            MessageGate <TestMessage, OtherMessage> gate = new();
            bool executed = false;

            using Timer timer = new(state =>
            {
                OtherMessage endMessage = new(Array.Empty <Message>());
                MessageDomain.CreateNewDomainsFor(endMessage);
                gate.Check(endMessage);
                executed = true;
            }, null, 200,
                                    Timeout.Infinite);
            MessageGateResult <OtherMessage> result = gate.SendAndAwait(startMessage, m => {}, 500);

            executed.Should().BeTrue("otherwise there is a timing issue.");
            result.Result.Should().Be(MessageGateResultKind.Timeout);
        }