Ejemplo n.º 1
0
        public void ThrowExceptionAsHandlerWorks()
        {
            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterInstance(new StateRecoveryOptions
                {
                    StateRecoveryStrategy = StateRecoveryStrategy.FromStateHolder
                });
                builder.RegisterType <StateAccessor>()
                .AsImplementedInterfaces()
                .SingleInstance();
            });
            var state = new TestState();

            mocker.Create <StateAccessor>().State = state;

            mocker.Mock <IEventSaver>()
            .Setup(x => x.SaveEventAsync(It.IsAny <IEvent>()))
            .Returns(Task.CompletedTask);

            mocker.Mock <IStateHolder>()
            .Setup(x => x.DeepCopy(It.IsAny <IState>()))
            .Returns(state);

            mocker.Mock <IEventHandlerFactory>()
            .SetupSequence(x => x.Create(It.IsAny <IEventContext>()))
            .Returns(new ExceptionHandler());

            var flow = mocker.Create <MasterEventHandlerFLow>();

            flow.Activate();
            Assert.ThrowsAsync <Exception>(() => flow.OnNewEventReceived(new TestEvent()));
            state.Version.Should().Be(0);
        }
Ejemplo n.º 2
0
        public void DeactivateAndSavingState()
        {
            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterInstance(new StateSavingOptions
                {
                    SaveWhenDeactivateAsync = true
                });
            });
            mocker.Mock <IEventHandledNotificationFlow>()
            .Setup(x => x.Deactivate());
            mocker.Mock <IStateSavingFlow>()
            .Setup(x => x.Deactivate());
            mocker.Mock <IEventHandlerFLow>()
            .Setup(x => x.Deactivate());

            var testState = new TestState();

            mocker.Mock <IStateAccessor>()
            .SetupGet(x => x.State)
            .Returns(testState);
            mocker.Mock <IStateSavingFlow>()
            .Setup(x => x.SaveStateAsync(testState))
            .Returns(Task.CompletedTask);

            IClaptrap claptrap = mocker.Create <ClaptrapActor>();

            claptrap.DeactivateAsync();
        }
        public void Deactivate_WithoutActivated()
        {
            using var mocker = AutoMockHelper.Create();
            var flow = mocker.Create <EventHandledNotificationFlow>();

            flow.Deactivate();
        }
        public void RemoveFactory()
        {
            const string typeCode = "testCode";

            using var mocker = AutoMockHelper.Create();
            var store         = mocker.Create <ClaptrapDesignStore>();
            var actorIdentity = new TestClaptrapIdentity("123", typeCode);
            var design        = new ClaptrapDesign
            {
                ClaptrapTypeCode = typeCode
            };

            store.AddOrReplace(design);
            store.AddOrReplaceFactory(typeCode,
                                      (identity, sourceDesign) => new ClaptrapDesign
            {
                StateDataType = typeof(int)
            });
            var claptrapDesign = store.FindDesign(actorIdentity);

            claptrapDesign.StateDataType.Should().Be(typeof(int));
            store.RemoveFactory(typeCode);
            claptrapDesign = store.FindDesign(actorIdentity);
            claptrapDesign.Should().Be(design);
        }
Ejemplo n.º 5
0
        public void WindowVersionLimit2()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                builder.RegisterInstance(new StateSavingOptions
                {
                    SavingWindowVersionLimit = 2
                });
            });
            var laterState = new TestState
            {
                Version = 1000
            };

            // setup only once, it means that this function can not be invoke twice
            mocker.Mock <IStateSaver>()
            .SetupSequence(x => x.SaveAsync(laterState))
            .Returns(Task.CompletedTask);

            var stateSavingFlow = mocker.Create <StateSavingFlow>();

            stateSavingFlow.Activate();

            // add two, by only save the later one
            stateSavingFlow.OnNewStateCreated(new TestState());
            stateSavingFlow.OnNewStateCreated(laterState);
        }
Ejemplo n.º 6
0
        public void ExceptionAdnContinue()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                builder.RegisterInstance(new StateSavingOptions
                {
                    SavingWindowVersionLimit = 1
                });
            });
            var laterState = new TestState
            {
                Version = 1000
            };

            mocker.Mock <IStateSaver>()
            .SetupSequence(x => x.SaveAsync(It.IsAny <IState>()))
            .Returns(Task.FromException(new Exception("something error while save state")))
            .Returns(Task.CompletedTask);

            var stateSavingFlow = mocker.Create <StateSavingFlow>();

            stateSavingFlow.Activate();

            // first will not save as there is a exception thrown
            stateSavingFlow.OnNewStateCreated(new TestState());

            // later one will be save as it is ok
            stateSavingFlow.OnNewStateCreated(laterState);
        }
        public async Task HandleVersionOlderEvent()
        {
            IState state = new TestState
            {
                Version = 1000
            };

            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterType <StateAccessor>()
                .AsImplementedInterfaces()
                .SingleInstance();
                builder.RegisterBuildCallback(scope => scope.Resolve <IStateAccessor>().State = state);
            });

            var flow = mocker.Create <MinionEventHandlerFLow>();

            flow.Activate();
            await flow.OnNewEventReceived(new TestEvent
            {
                Version = 1
            });

            state.Version.Should().Be(1000,
                                      "do nothing as event version 1 lte state next version 1000 , skip the event");
            await flow.OnNewEventReceived(new TestEvent
            {
                Version = 1000
            });

            state.Version.Should().Be(1000,
                                      "do nothing as event version 1000 lte state next version 1000 , skip the event");
        }
Ejemplo n.º 8
0
        public void CreateMinion()
        {
            var actorIdentity       = TestClaptrapIdentity.Instance;
            var claptrapDesignStore = new ClaptrapDesignStore();
            var masterDesign        = new ClaptrapDesign
            {
                ClaptrapOptions = new ClaptrapOptions
                {
                    MinionActivationOptions = new MinionActivationOptions(),
                    EventLoadingOptions     = new EventLoadingOptions(),
                    StateRecoveryOptions    = new StateRecoveryOptions(),
                    StateSavingOptions      = new StateSavingOptions()
                },
                ClaptrapTypeCode               = actorIdentity.TypeCode,
                EventHandlerDesigns            = ImmutableDictionary <string, IClaptrapEventHandlerDesign> .Empty,
                StateHolderFactoryType         = typeof(NoChangeStateHolderFactory),
                StateDataType                  = typeof(TestStateData),
                EventHandlerFactoryFactoryType = typeof(EventHandlerFactoryFactory),
                InitialStateDataFactoryType    = typeof(DefaultInitialStateDataFactory)
            };

            claptrapDesignStore.AddOrReplace(masterDesign);
            var minionDesign = new ClaptrapDesign
            {
                ClaptrapOptions = new ClaptrapOptions
                {
                    MinionActivationOptions = new MinionActivationOptions(),
                    EventLoadingOptions     = new EventLoadingOptions(),
                    StateRecoveryOptions    = new StateRecoveryOptions(),
                    StateSavingOptions      = new StateSavingOptions()
                },
                ClaptrapTypeCode               = actorIdentity.TypeCode,
                EventHandlerDesigns            = ImmutableDictionary <string, IClaptrapEventHandlerDesign> .Empty,
                StateHolderFactoryType         = typeof(NoChangeStateHolderFactory),
                StateDataType                  = typeof(TestStateData),
                EventHandlerFactoryFactoryType = typeof(EventHandlerFactoryFactory),
                InitialStateDataFactoryType    = typeof(DefaultInitialStateDataFactory),
                ClaptrapMasterDesign           = masterDesign
            };

            claptrapDesignStore.AddOrReplace(minionDesign);
            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                builder.RegisterInstance(claptrapDesignStore)
                .AsImplementedInterfaces()
                .SingleInstance();
            });

            mocker.Mock <IClaptrapModuleProvider>()
            .Setup(x => x.GetClaptrapSharedModules(actorIdentity))
            .Returns(Enumerable.Empty <IClaptrapSharedModule>());
            mocker.Mock <IClaptrapModuleProvider>()
            .Setup(x => x.GetClaptrapMinionModules(actorIdentity))
            .Returns(Enumerable.Empty <IClaptrapMinionModule>());

            var actorFactory = mocker.Create <ClaptrapFactory>();
            var actor        = actorFactory.Create(actorIdentity);

            actor.Should().NotBeNull();
        }
        public void Create()
        {
            using var mocker = AutoMockHelper.Create();
            var actorIdentity = new TestClaptrapIdentity(Guid.NewGuid().ToString(), "typeCode");
            var testEvent     = new TestEvent
            {
                EventTypeCode = "eventType"
            };
            var eventContext = new EventContext(testEvent, new TestState
            {
                Identity = actorIdentity
            });

            mocker.Mock <IClaptrapDesignStore>()
            .Setup(x => x.FindDesign(actorIdentity))
            .Returns(new ClaptrapDesign
            {
                EventHandlerDesigns = new Dictionary <string, IClaptrapEventHandlerDesign>
                {
                    {
                        testEvent.EventTypeCode, new ClaptrapEventHandlerDesign
                        {
                            EventHandlerType = typeof(TestHandler)
                        }
                    }
                }
            });

            var eventHandlerFactory = mocker.Create <DesignBaseEventHandlerFactory>();
            var eventHandler        = eventHandlerFactory.Create(eventContext);

            eventHandler.Should().NotBeNull();
        }
Ejemplo n.º 10
0
        public async Task RestoreStateWithSomeEvents()
        {
            using var mocker = AutoMockHelper.Create();

            var state = new TestState();

            mocker.Mock <IStateLoader>()
            .Setup(x => x.GetStateSnapshotAsync())
            .ReturnsAsync(state);

            mocker.Mock <IEventLoader>()
            .SetupSequence(x => x.GetEventsAsync(It.IsAny <long>(), It.IsAny <long>()))
            .ReturnsAsync(AllEvents())
            .ReturnsAsync(Enumerable.Empty <IEvent>());

            mocker.Mock <IEventHandlerFactory>()
            .Setup(x => x.Create(It.IsAny <IEventContext>()))
            .Returns(new TestHandler());
            mocker.Mock <IStateAccessor>()
            .SetupProperty(x => x.State);

            var restorer = mocker.Create <StateRestorer>();
            await restorer.RestoreAsync();

            state.Version.Should().Be(3);
        public async Task HandleVersionMoreThanNextVersionEvent()
        {
            IState state = new TestState
            {
                Version = 1000
            };

            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterType <StateAccessor>()
                .AsImplementedInterfaces()
                .SingleInstance();
                builder.RegisterBuildCallback(scope => scope.Resolve <IStateAccessor>().State = state);
                builder.RegisterInstance(new EventLoadingOptions
                {
                    LoadingCountInOneBatch = 1000
                });
            });

            mocker.Mock <IStateHolder>()
            .Setup(x => x.DeepCopy(It.IsAny <IState>()))
            .Returns(state);

            mocker.Mock <IEventHandlerFactory>()
            .Setup(x => x.Create(It.IsAny <IEventContext>()))
            .Returns(new TestHandler());

            mocker.Mock <IStateSavingFlow>()
            .Setup(x => x.OnNewStateCreated(It.IsAny <IState>()));

            mocker.Mock <IEventLoader>()
            .Setup(x => x.GetEventsAsync(It.IsAny <long>(), It.IsAny <long>()))
            .Returns <long, long>((left, right) => Task.FromResult(Enumerable
                                                                   .Range((int)left, (int)right - (int)left)
                                                                   .Select(i => new TestEvent
            {
                Version = i,
            }).Cast <IEvent>()))
            .Callback <long, long>((left, right) => Console.WriteLine($"left {left} right {right}"));

            var flow = mocker.Create <MinionEventHandlerFLow>();

            flow.Activate();
            await flow.OnNewEventReceived(new TestEvent
            {
                Version = 1002
            });

            state.Version.Should().Be(1002,
                                      "do nothing as event version 1002 gt state next version 1000 , read event from event store");
            await flow.OnNewEventReceived(new TestEvent
            {
                Version = 2000
            });

            state.Version.Should().Be(2000,
                                      "do nothing as event version 2000 gt state next version 1000 , read event from event store");
        }
 public void NotFound()
 {
     using var mocker = AutoMockHelper.Create();
     var claptrapDesignStore = mocker.Create<ClaptrapDesignStore>();
     var actorIdentity = new TestClaptrapIdentity("123", "testCode");
     Assert.Throws<ClaptrapDesignNotFoundException>(() =>
         claptrapDesignStore.FindDesign(actorIdentity));
 }
        public void AllNull()
        {
            using var mocker = AutoMockHelper.Create();
            var validator = mocker.Create <ClaptrapDesignStoreValidator>();

            var(isOk, errorMessage) = validator.Validate(new[] { new ClaptrapDesign() });
            isOk.Should().Be(false);
            errorMessage.Should().NotBeNullOrEmpty();
            Console.WriteLine(errorMessage);
        }
        public async Task ConcurrentMixOrder()
        {
            const int targetVersion = 10000;
            IState    state         = new TestState
            {
                Version = 500
            };

            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterType <StateAccessor>()
                .AsImplementedInterfaces()
                .SingleInstance();
                builder.RegisterBuildCallback(scope => scope.Resolve <IStateAccessor>().State = state);
                builder.RegisterInstance(new EventLoadingOptions
                {
                    LoadingCountInOneBatch = 1000
                });
            });
            var sourceEvents = Enumerable.Range(0, targetVersion + 1).Select(x => new TestEvent
            {
                Version = x
            }).ToArray();
            var sendingEvents = sourceEvents.ToList();

            Shuffle(sendingEvents);

            mocker.Mock <IEventLoader>()
            .Setup(x => x.GetEventsAsync(It.IsAny <long>(), It.IsAny <long>()))
            .Returns <long, long>((left, right) => Task.FromResult(sourceEvents
                                                                   .Skip((int)left)
                                                                   .Take((int)(right - left))
                                                                   .Cast <IEvent>()))
            .Callback <long, long>((left, right) => Console.WriteLine($"left {left} right {right}"));

            mocker.Mock <IStateHolder>()
            .Setup(x => x.DeepCopy(It.IsAny <IState>()))
            .Returns(state);

            mocker.Mock <IEventHandlerFactory>()
            .Setup(x => x.Create(It.IsAny <IEventContext>()))
            .Returns(new TestHandler());

            mocker.Mock <IStateSavingFlow>()
            .Setup(x => x.OnNewStateCreated(It.IsAny <IState>()));

            var flow = mocker.Create <MinionEventHandlerFLow>();

            flow.Activate();

            await Task.WhenAll(sendingEvents.Select(flow.OnNewEventReceived));

            state.Version.Should().Be(targetVersion);
        }
        public async Task Success()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder => { });
            var context = new EventNotifierContext();

            mocker.Mock <IEventNotifierHandler>()
            .Setup(x => x.Notify(context))
            .Returns(Task.CompletedTask);
            var notifier = mocker.Create <CompoundEventNotifier>();
            await notifier.Notify(context);
        }
Ejemplo n.º 16
0
        public async Task HandleEventConcurrently(int count)
        {
            using var mocker = AutoMockHelper.Create(
                      builderAction: builder =>
            {
                builder.RegisterInstance(new StateRecoveryOptions());
                builder.RegisterType <StateAccessor>()
                .AsImplementedInterfaces()
                .SingleInstance();
            });
            var state = new TestState
            {
                Data = new TestStateData
                {
                    Counter = 0
                }
            };

            mocker.Create <StateAccessor>().State = state;
            var savedEvents = new ConcurrentBag <IEvent>();

            mocker.Mock <IEventSaver>()
            .Setup(x => x.SaveEventAsync(It.IsAny <IEvent>()))
            .Returns(Task.CompletedTask)
            .Callback <IEvent>(e => savedEvents.Add(e));

            mocker.Mock <IStateHolder>()
            .Setup(x => x.DeepCopy(It.IsAny <IState>()))
            .Returns(state);

            mocker.Mock <IEventHandlerFactory>()
            .Setup(x => x.Create(It.IsAny <IEventContext>()))
            .Returns(new TestHandler());

            mocker.Mock <IEventHandledNotificationFlow>()
            .Setup(x => x.OnNewEventHandled(It.IsAny <IEventNotifierContext>()));

            mocker.Mock <IStateSavingFlow>()
            .Setup(x => x.OnNewStateCreated(It.IsAny <IState>()));

            var flow = mocker.Create <MasterEventHandlerFLow>();

            flow.Activate();
            await Task.WhenAll(Enumerable.Range(0, count).Select(x => flow.OnNewEventReceived(new TestEvent())));

            state.Version.Should().Be(count);
            ((TestStateData)state.Data).Counter.Should().Be(count);
            savedEvents.Count.Should().Be(count);
            savedEvents
            .Select(x => x.Version)
            .OrderBy(x => x)
            .Should()
            .BeEquivalentTo(Enumerable.Range(Defaults.EventStartingVersion, count));
        }
Ejemplo n.º 17
0
 public async Task DeactivateAsync()
 {
     using var mocker = AutoMockHelper.Create();
     mocker.Mock <IEventHandledNotificationFlow>()
     .Setup(x => x.Deactivate());
     mocker.Mock <IStateSavingFlow>()
     .Setup(x => x.Deactivate());
     mocker.Mock <IEventHandlerFLow>()
     .Setup(x => x.Deactivate());
     IClaptrap claptrap = mocker.Create <ClaptrapActor>();
     await claptrap.DeactivateAsync();
 }
        public void ExceptionAndContinue()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder => { });
            var context = new EventNotifierContext();

            mocker.Mock <IEventNotifierHandler>()
            .Setup(x => x.Notify(context))
            .Throws(new ArgumentNullException());
            var notifier = mocker.Create <CompoundEventNotifier>();

            Assert.ThrowsAsync <ArgumentNullException>(() => notifier.Notify(context));
        }
        public void NothingAdded()
        {
            var serviceCollection    = new ServiceCollection().AddLogging(logging => logging.AddConsole());
            var buildServiceProvider = serviceCollection.BuildServiceProvider();
            var loggerFactory        = buildServiceProvider.GetRequiredService <ILoggerFactory>();

            using var mocker = AutoMockHelper.Create();
            var containerBuilder     = new ContainerBuilder();
            var builder              = new AutofacClaptrapBootstrapperBuilder(loggerFactory, containerBuilder);
            var claptrapBootstrapper = builder.Build();

            claptrapBootstrapper.Should().NotBeNull();
        }
Ejemplo n.º 20
0
        public void NotSave()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                // there is no saving windows set, it will save nothing
                builder.RegisterInstance(new StateSavingOptions());
            });

            var stateSavingFlow = mocker.Create <StateSavingFlow>();

            stateSavingFlow.Activate();
            stateSavingFlow.OnNewStateCreated(new TestState());
        }
 public void Remove()
 {
     using var mocker = AutoMockHelper.Create();
     var claptrapDesignStore = mocker.Create<ClaptrapDesignStore>();
     const string typeCode = "testCode";
     var design = new ClaptrapDesign
     {
         ClaptrapTypeCode = typeCode
     };
     claptrapDesignStore.AddOrReplace(design);
     claptrapDesignStore.Remove(x => x.ClaptrapTypeCode == typeCode);
     claptrapDesignStore.ToArray().Should().BeEmpty();
 }
 public void DesignFound()
 {
     using var mocker = AutoMockHelper.Create();
     var claptrapDesignStore = mocker.Create<ClaptrapDesignStore>();
     const string typeCode = "testCode";
     var design = new ClaptrapDesign
     {
         ClaptrapTypeCode = typeCode
     };
     claptrapDesignStore.AddOrReplace(design);
     var claptrapDesign = claptrapDesignStore.FindDesign(new TestClaptrapIdentity("456", typeCode));
     claptrapDesign.Should().Be(design);
 }
 public void Add(string typeCode)
 {
     using var mocker = AutoMockHelper.Create();
     var claptrapDesignStore = mocker.Create<ClaptrapDesignStore>();
     var actorIdentity = new TestClaptrapIdentity("123", typeCode);
     var design = new ClaptrapDesign
     {
         ClaptrapTypeCode = typeCode
     };
     claptrapDesignStore.AddOrReplace(design);
     var claptrapDesign = claptrapDesignStore.FindDesign(actorIdentity);
     claptrapDesign.Should().Be(design);
 }
Ejemplo n.º 24
0
        public async Task HandleEventAsyncWithInterceptorException()
        {
            using var mocker = AutoMockHelper.Create();
            var testEvent = new TestEvent();

            mocker.Mock <IClaptrapLifetimeInterceptor>()
            .Setup(x => x.HandlingEventAsync(testEvent))
            .Returns(Task.FromException <Exception>(new Exception()));
            mocker.Mock <IClaptrap>()
            .Setup(x => x.HandleEventAsync(testEvent))
            .Returns(Task.CompletedTask);
            var claptrap = mocker.Create <AopClaptrap>();
            await claptrap.HandleEventAsync(testEvent);
        }
Ejemplo n.º 25
0
 public async Task ActivateAsync()
 {
     using var mocker = AutoMockHelper.Create();
     mocker.Mock <IEventHandledNotificationFlow>()
     .Setup(x => x.Activate());
     mocker.Mock <IStateSavingFlow>()
     .Setup(x => x.Activate());
     mocker.Mock <IEventHandlerFLow>()
     .Setup(x => x.Activate());
     mocker.Mock <IStateRestorer>()
     .Setup(x => x.RestoreAsync())
     .Returns(Task.CompletedTask);
     IClaptrap claptrap = mocker.Create <ClaptrapActor>();
     await claptrap.ActivateAsync();
 }
Ejemplo n.º 26
0
 public async Task DeactivateAsync()
 {
     using var mocker = AutoMockHelper.Create();
     mocker.Mock <IClaptrapLifetimeInterceptor>()
     .Setup(x => x.DeactivatingAsync())
     .Returns(Task.CompletedTask);
     mocker.Mock <IClaptrapLifetimeInterceptor>()
     .Setup(x => x.DeactivatedAsync())
     .Returns(Task.CompletedTask);
     mocker.Mock <IClaptrap>()
     .Setup(x => x.DeactivateAsync())
     .Returns(Task.CompletedTask);
     var claptrap = mocker.Create <AopClaptrap>();
     await claptrap.DeactivateAsync();
 }
Ejemplo n.º 27
0
        public void DesignNotFound()
        {
            var actorIdentity       = TestClaptrapIdentity.Instance;
            var claptrapDesignStore = new ClaptrapDesignStore();

            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                builder.RegisterInstance(claptrapDesignStore)
                .AsImplementedInterfaces()
                .SingleInstance();
            });

            var actorFactory = mocker.Create <ClaptrapFactory>();

            Assert.Throws <ClaptrapDesignNotFoundException>(() => actorFactory.Create(actorIdentity));
        }
        public void OnNewEventHandled()
        {
            using var mocker = AutoMockHelper.Create();
            mocker.Mock <IEventNotifier>()
            .Setup(x => x.Notify(It.IsAny <IEventNotifierContext>()))
            .Returns(Task.CompletedTask);
            var flow = mocker.Create <EventHandledNotificationFlow>();

            flow.Activate();
            flow.OnNewEventHandled(new EventNotifierContext
            {
                Event        = new TestEvent(),
                CurrentState = new TestState(),
                OldState     = new TestState()
            });
        }
        public void OnNewEventHandled_NotifierException()
        {
            using var mocker = AutoMockHelper.Create();
            mocker.Mock <IEventNotifier>()
            .Setup(x => x.Notify(It.IsAny <IEventNotifierContext>()))
            .Returns(Task.FromException(new Exception("failed to send notification")));
            var flow = mocker.Create <EventHandledNotificationFlow>();

            flow.Activate();
            flow.OnNewEventHandled(new EventNotifierContext
            {
                Event        = new TestEvent(),
                CurrentState = new TestState(),
                OldState     = new TestState()
            });
        }
Ejemplo n.º 30
0
        public void WindowVersionLimitTime1Seconds()
        {
            using var mocker = AutoMockHelper.Create(builderAction: builder =>
            {
                builder.RegisterInstance(new StateSavingOptions
                {
                    SavingWindowTime = TimeSpan.FromSeconds(1)
                });
            });

            var stateSavingFlow = mocker.Create <StateSavingFlow>();

            stateSavingFlow.Activate();
            stateSavingFlow.OnNewStateCreated(new TestState());

            // there will be nothing saved since it deactivate with 1 sec
        }