示例#1
0
        public Given_Automatonymous_Process(Func <SoftwareProgrammingProcess, State> initialState)
        {
            var process = new SoftwareProgrammingProcess();

            State   = new SoftwareProgrammingState(Guid.NewGuid().ToString(), initialState(process).Name);
            Process = new SoftwareProgrammingProcess();
        }
示例#2
0
        public async Task Given_instance_process_When_recovering_from_creation()
        {
            var aggregateFactory = new AggregateFactory();
            var processId        = Guid.NewGuid().ToString();

            var data         = aggregateFactory.Build <ProcessStateAggregate <SoftwareProgrammingState> >(processId);
            var process      = new SoftwareProgrammingProcess();
            var initialState = new SoftwareProgrammingState(processId, process.MakingCoffee.Name);

            var eventsToReplay = new DomainEvent[] { new ProcessManagerCreated <SoftwareProgrammingState>(initialState, processId) };

            data.ApplyEvents(eventsToReplay);

            var processManager = new SoftwareProgrammingProcess();

            //Try to transit process by message, available only in desired state
            var coffeMakeFailedEvent = new CoffeMakeFailedEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
            var dispatchedCommands   = await processManager.Transit(data.State, coffeMakeFailedEvent);

            //process_produce_commands_only_one_command()
            Assert.Equal(1, dispatchedCommands.Count);
            //Produced_command_has_right_person_id()
            var sleepCommand = dispatchedCommands.OfType <GoSleepCommand>().First();

            Assert.Equal(coffeMakeFailedEvent.ForPersonId, sleepCommand.PersonId);
            //Produced_command_has_right_sofa_id()
            Assert.Equal(data.State.SofaId, sleepCommand.SofaId);
            //process_produce_command_from_given_state()
            Assert.IsAssignableFrom <GoSleepCommand>(dispatchedCommands.FirstOrDefault());
        }
示例#3
0
        public async Task Test()
        {
            var i       = Node.Id; //just start node
            var process = new SoftwareProgrammingProcess();
            var state   = new SoftwareProgrammingState(Guid.NewGuid().ToString(), process.Coding.Name, Guid.NewGuid().ToString(), Guid.NewGuid().ToString());

            var processStateAggregate = new ProcessStateAggregate <SoftwareProgrammingState>(state);

            processStateAggregate.ReceiveMessage(state, null);
            processStateAggregate.ClearUncommitedEvents();

            var repo = new AggregateSnapshotRepository(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
                                                       AggregateFactory.Default,
                                                       AggregateFactory.Default);
            await repo.Add(processStateAggregate);

            var restoredState = await this.LoadProcessByActor <SoftwareProgrammingState>(processStateAggregate.Id);

            //CoffeMachineId_should_be_equal()
            Assert.Equal(processStateAggregate.State.CoffeeMachineId, restoredState.CoffeeMachineId);
            // State_should_be_equal()
            Assert.Equal(processStateAggregate.State.CurrentStateName, restoredState.CurrentStateName);
        }