示例#1
0
        public void LoadingEventsForActiveStateMachine(
            AsyncActiveStateMachine <string, int> machine)
        {
            "establish a passive state machine".x(() =>
            {
                var stateMachineDefinitionBuilder = new StateMachineDefinitionBuilder <string, int>();
                stateMachineDefinitionBuilder
                .In("A")
                .On(1)
                .Goto("B");
                stateMachineDefinitionBuilder
                .In("B")
                .On(2)
                .Goto("C");
                stateMachineDefinitionBuilder
                .In("C")
                .On(3)
                .Goto("A");
                machine = stateMachineDefinitionBuilder
                          .WithInitialState("A")
                          .Build()
                          .CreateActiveStateMachine();
            });

            "when it is loaded with Events".x(async() =>
            {
                var firstEvent    = new EventInformation <int>(2, null);
                var secondEvent   = new EventInformation <int>(3, null);
                var priorityEvent = new EventInformation <int>(1, null);
                var loader        = new StateMachineLoader <string, int>();
                loader.SetEvents(new List <EventInformation <int> >
                {
                    firstEvent,
                    secondEvent,
                });
                loader.SetPriorityEvents(new List <EventInformation <int> >
                {
                    priorityEvent
                });

                var extension = A.Fake <IExtension <string, int> >();
                machine.AddExtension(extension);

                await machine.Load(loader);

                A.CallTo(() => extension.Loaded(
                             A <IStateMachineInformation <string, int> > .Ignored,
                             A <Initializable <string> > .Ignored,
                             A <IReadOnlyDictionary <string, string> > .Ignored,
                             A <IReadOnlyCollection <EventInformation <int> > >
                             .That
                             .Matches(c =>
                                      c.Count == 2 &&
                                      c.Contains(firstEvent) &&
                                      c.Contains(secondEvent)),
                             A <IReadOnlyCollection <EventInformation <int> > >
                             .That
                             .Matches(c =>
                                      c.Count == 1 &&
                                      c.Contains(priorityEvent))))
                .MustHaveHappenedOnceExactly();
            });

            "it should process those events".x(async() =>
            {
                var transitionRecords        = new List <TransitionRecord>();
                machine.TransitionCompleted += (sender, args) =>
                                               transitionRecords.Add(
                    new TransitionRecord(args.EventId, args.StateId, args.NewStateId));

                var signal = SetUpWaitForAllTransitions(machine, 3);
                await machine.Start();
                WaitForAllTransitions(signal);

                transitionRecords
                .Should()
                .HaveCount(3)
                .And
                .IsEquivalentInOrder(new List <TransitionRecord>
                {
                    new TransitionRecord(1, "A", "B"),
                    new TransitionRecord(2, "B", "C"),
                    new TransitionRecord(3, "C", "A")
                });
            });
        }