Esempio n. 1
0
        public async Task When_InAsyncState_AndTransitionWithEvent_Than_GeneratedEventIsRaisedWhenNecessary(bool generateEvent)
        {
            // Arrange
            var eventSut = CreateEventSut();

            this.sut = eventSut;
            var detectTaskCompletionSource = new TaskCompletionSource <bool>();

            this.detectionManager.Setup(m => m.Detect()).Returns(detectTaskCompletionSource.Task);

            await DoStateChange(new TestCommand());
            await DoStateChange(new StartDetectionCommand());

            this.detectionManager.Reset();

            EventGeneratedEventArgs <GeneratedEventBase> generatedEvent = null;

            eventSut.EventGenerated += (s, e) => { generatedEvent = e; };

            // Act
            await DoStateChange(new TransitionEventCommand(generateEvent));

            // Assert
            if (generateEvent)
            {
                Assert.IsType <FirstEvent>(generatedEvent.Event);
            }
            else
            {
                Assert.Null(generatedEvent);
            }
        }
Esempio n. 2
0
        public async Task When_TransitionEventCommand_Than_Transitions_To_TestState_And_GeneratedEventIsRaisedWhenNecessary(bool generateEvent)
        {
            // Arrange
            var eventSut = CreateEventSut();

            this.sut = eventSut;

            var seq = new MockSequence();

            this.transitionsTester.InSequence(seq).Setup(m => m.OnLeaveInitial(It.IsAny <InitialState>()));
            this.transitionsTester.InSequence(seq).Setup(m => m.OnEnterTest(It.IsAny <TestState>()));

            var transition = NextStateChanged().Timeout(TimeoutDuration);

            EventGeneratedEventArgs <GeneratedEventBase> generatedEvent = null;

            eventSut.EventGenerated += (s, e) => { generatedEvent = e; };

            // Act
            this.sut.Process(new TransitionEventCommand(generateEvent));
            var e = await transition;

            // Assert
            Assert.IsType <TestState>(this.sut.CurrentState);
            Assert.IsType <TestState>(e.CurrentState);
            Assert.IsType <InitialState>(e.PreviousState);
            if (generateEvent)
            {
                Assert.IsType <FirstEvent>(generatedEvent.Event);
            }
            else
            {
                Assert.Null(generatedEvent);
            }

            this.transitionsTester.Verify(m => m.OnLeaveInitial(It.IsAny <InitialState>()), Times.Once);
            this.transitionsTester.Verify(m => m.OnEnterTest(It.IsAny <TestState>()), Times.Once);
        }