public async Task ExecuteEntryActionAsync_executes_for_super_state() { var entryActionCalled = false; var stateMachine = new StateMachine <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var openConfig = new StateConfiguration <Sale, SaleState, SaleEvent>(SaleState.Open, stateMachine); openConfig.AddEntryAction((sale1, _) => { entryActionCalled = true; return(Task.CompletedTask); }); var changeDueConfig = new StateConfiguration <Sale, SaleState, SaleEvent>(SaleState.ChangeDue, stateMachine); changeDueConfig.MakeSubStateOf(openConfig); var sale = new Sale(saleId: 96) { State = SaleState.ChangeDue }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale); var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay , SaleState.Open , SaleState.Complete , SaleState.ChangeDue , "lastTransitionName"); await changeDueConfig.ExecuteEntryActionAsync(parameters, transitionResult); Assert.True(entryActionCalled); }
public async Task FireTriggerAsync_executes_superState_if_currentState_not_successful() { var sale = new Sale(saleID: 96) { State = SaleState.ChangeDue }; var stateMachine = new StateMachineAsync <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var openState = new StateConfigurationAsync <Sale, SaleState, SaleEvent>(SaleState.Open, stateMachine); var changeDueState = new StateConfigurationAsync <Sale, SaleState, SaleEvent>(SaleState.ChangeDue, stateMachine); var openStatePayTriggerFired = false; openState .AddTriggerAction(SaleEvent.Pay, (sale1, _) => { openStatePayTriggerFired = true; return(Task.CompletedTask); }) .AddTransition(SaleEvent.Pay, SaleState.Complete, name: "openStatePay"); changeDueState.AddSuperState(openState); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale); var result = await changeDueState.FireTriggerAsync(parameters); Assert.True(openStatePayTriggerFired); Assert.True(result.WasTransitioned); Assert.Equal(SaleState.Complete, sale.State); Assert.Equal(SaleState.Complete, result.CurrentState); Assert.Equal(SaleState.ChangeDue, result.PreviousState); Assert.Equal(SaleState.ChangeDue, result.StartingState); Assert.Equal("openStatePay", result.LastTransitionName); }
public StateTransitionResult <TState, TTrigger> FireTrigger(ExecutionParameters <T, TTrigger> parameters) { if (_triggerActions.TryGetValue(parameters.Trigger, out var triggerAction)) { triggerAction.Execute(parameters); } var result = FireTriggerPrim(parameters); if (!(result?.WasTransitioned ?? false) && SuperStateConfig != null) { result = SuperStateConfig.FireTrigger(parameters); } else { var startState = StateAccessor(parameters.Context); result ??= new StateTransitionResult <TState, TTrigger>(parameters.Trigger , startState , startState , startState , string.Empty , transitionDefined: false); } return(result); }
public async Task ExecuteAsync_does_not_execute_if_cancel_requested() { const SaleState startState = SaleState.Open; var sale = new Sale(saleID: 66) { State = startState }; var sut = new StateTransitionAutoFallbackParameterizedAsync <Sale, SaleState, SaleEvent, string>( getStateMachine() , SaleState.Complete , SaleState.Complete , SaleState.Open , conditionAsync: (_, stringParam, cancelToken) => Task.FromResult(result: true) , name: "test" , priority: 1); using (var cancelSource = new CancellationTokenSource()) { var cancelToken = cancelSource.Token; cancelSource.Cancel(); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, request: "notUsed", cancellationToken: cancelToken); var result = await sut.ExecuteAsync(parameters, getDummyResult(wasCancelled : true)); Assert.True(result.WasCancelled); Assert.False(result.WasTransitioned); Assert.Equal(startState, sale.State); } }
public async Task ExecuteReentryActionAsync_executes_ReentryAction() { var sale = new Sale(saleID: 96) { State = SaleState.Open }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.AddItem , SaleState.Open , SaleState.Open , SaleState.Open , "lastTransitionName"); var stateMachine = new StateMachineAsync <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var openState = new StateConfigurationAsync <Sale, SaleState, SaleEvent>(SaleState.Open, stateMachine); var changeDueState = new StateConfigurationAsync <Sale, SaleState, SaleEvent>(SaleState.ChangeDue, stateMachine); changeDueState.AddSuperState(openState); var changeDueEntryActionFromOpenFired = false; changeDueState.AddReentryAction((sale1, _) => { changeDueEntryActionFromOpenFired = true; return(Task.CompletedTask); }); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale); await changeDueState.ExecuteReentryActionAsync(parameters, transitionResult); Assert.True(changeDueEntryActionFromOpenFired); }
public void ExecuteAutoTransition_executes_AutoTransition_for_superState() { //Scenario: Sale has been paid for and goes to ChangeDue. If no change due, it should automatically transition to Complete. //ChangeDue is a substate of Open and Open has the autoForward defined for Pay. var sale = new Sale(saleID: 96) { State = SaleState.ChangeDue }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.AddItem , SaleState.Open , SaleState.Open , SaleState.ChangeDue , "lastTransitionName"); var stateMachine = new StateMachine <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); IStateConfigurationInternal <Sale, SaleState, SaleEvent> openState = stateMachine.ConfigureState(SaleState.Open) as IStateConfigurationInternal <Sale, SaleState, SaleEvent>; IStateConfigurationInternal <Sale, SaleState, SaleEvent> changeDueState = stateMachine.ConfigureState(SaleState.ChangeDue) as IStateConfigurationInternal <Sale, SaleState, SaleEvent>; changeDueState?.AddSuperState(openState); openState?.AddAutoForwardTransition(SaleEvent.Pay, SaleState.Complete, sale1 => true /* condition indicates no change due */); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale); var autoTransitionResult = changeDueState?.ExecuteAutoTransition(parameters, transitionResult); Assert.True(autoTransitionResult?.WasTransitioned); Assert.Equal(SaleState.Complete, sale.State); Assert.Equal(SaleState.Complete, autoTransitionResult?.CurrentState); Assert.Equal(SaleState.ChangeDue, autoTransitionResult?.PreviousState); Assert.Equal(SaleState.Open, autoTransitionResult?.StartingState); }
/// <summary> /// Executes demo live tests. /// </summary> internal static void RunLiveTests() { // set package execution parameters eg. variables, connections var parameters = new ExecutionParameters(); // add variables and their values to be set when the package has been loaded parameters.AddVariable(@"\[Main].[ConnectionString]", Constants.SsisDbConnectionString); parameters.AddVariable(@"\[Main].[CopyCustomersPath]", Constants.PathToCopyCustomersPackage); parameters.AddVariable(@"\[Main].[LoadCustomersPath]", Constants.PathToLoadCustomersPackage); parameters.AddVariable(@"\[Main].[ConvertDestinationPath]", Constants.CustomersFileConverted); parameters.AddVariable(@"\[Main].[DestinationPath]", Constants.CustomersFileDestination); parameters.AddVariable(@"\[Main].[SourcePath]", Constants.CustomersFileSource); // create engine for live testing var engine = EngineFactory.GetClassInstance <ILiveTestEngine>(); // load packages and relate them to the logical group - repository engine.LoadPackages("DEMO", Constants.PathToPackages); // load live tests from the current assembly engine.LoadRepositoryActions("DEMO"); // set execution parameters engine.SetExecutionParameters(parameters); // execute the package and attach live tests engine.ExecuteLiveTestsWithGui("DEMO", "Main.dtsx"); }
public AvalancheRunnerTests() { _logger = Substitute.For <ILogger <AvalancheRunner> >(); _glacier = Substitute.For <IGlacierGateway>(); _lightroom = Substitute.For <ILightroomReader>(); _avalanche = Substitute.For <IAvalancheRepository>(); _parameters = new ExecutionParameters { Glacier = new GlacierParameters { }, Avalanche = new AvalancheParameters { } }; _glacierFactory = Substitute.For <IInjectionFactory <IGlacierGateway> >(); _glacierFactory.Create().Returns(_glacier); _lightroomFactory = Substitute.For <IInjectionFactory <ILightroomReader> >(); _lightroomFactory.Create().Returns(_lightroom); _lightroom.GetCatalogId().Returns(Guid.NewGuid()); _avalancheFactory = Substitute.For <IInjectionFactory <IAvalancheRepository> >(); _avalancheFactory.Create().Returns(_avalanche); _sut = new AvalancheRunner(_logger, _glacierFactory, _lightroomFactory, _avalancheFactory, _parameters); }
public void ExecutionParametersToString() { var ep = new ExecutionParameters(); const string expectedString = "Model: \r\nSolver: SSA\r\nConfig: \r\nDuration: 100\r\nSamples: 100\r\nRuns: 1\r\nWorking Directory: .\r\n"; Assert.AreEqual(expectedString, ep.ToString()); }
public async Task ExecuteAsync_doesnt_execute_if_CancelRequested() { const SaleState startState = SaleState.Open; var sale = new Sale(saleID: 66) { State = startState }; var sut = new StateTransitionAsync <Sale, SaleState, SaleEvent>( stateAccessor: saleToUpdate => saleToUpdate.State , stateMutator: (saleToUpdate, newState) => saleToUpdate.State = newState , toState: SaleState.Complete , conditionAsync: (_, inCancelToken) => Task.FromResult(result: true) , name: "test" , priority: 1); using (var cancelSource = new CancellationTokenSource()) { var cancelToken = cancelSource.Token; cancelSource.Cancel(); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, request: null, cancellationToken: cancelToken); var result = await sut.ExecuteAsync(parameters); Assert.True(result.WasCancelled); Assert.False(result.WasTransitioned); Assert.Equal(startState, sale.State); } }
public void Execute_transitions_when_matched() { var notificationReceived = false; var stateMachine = getStateMachine(); stateMachine.RegisterOnTransitionedAction((sale, _) => notificationReceived = true); var sut = new StateTransitionAutoDynamicParameterizedAsync <Sale, SaleState, SaleEvent, string>(stateMachine , SaleState.Open , (sale, stringParam) => SaleState.Complete , SaleState.ChangeDue , "autocomplete" , 1); var testSale = new Sale(2) { State = SaleState.Open }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, testSale, request: "testParam"); var previousResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay, SaleState.Open, SaleState.Open, SaleState.ChangeDue, "previousTransition"); var result = sut.Execute(parameters, previousResult); Assert.True(result.WasTransitioned); Assert.Equal("autocomplete", result.LastTransitionName); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.ChangeDue, SaleState.ChangeDue); Assert.Equal(SaleState.Open, result.StartingState); Assert.Equal(SaleState.Complete, testSale.State); Assert.True(notificationReceived); }
public void ExecuteAsync_ConditionAsync_can_be_cancelled() { const SaleState startState = SaleState.Open; var sale = new Sale(saleID: 66) { State = startState }; var sut = new StateTransitionAsync <Sale, SaleState, SaleEvent>( stateAccessor: saleToUpdate => saleToUpdate.State , stateMutator: (saleToUpdate, newState) => saleToUpdate.State = newState , toState: SaleState.Complete , conditionAsync: (_, cancellationToken) => { Task.Delay(millisecondsDelay: 999999, cancellationToken: cancellationToken); return(Task.FromResult(!cancellationToken.IsCancellationRequested)); } , name: "test" , priority: 1); using (var cancelSource = new CancellationTokenSource()) { var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancellationToken: cancelSource.Token); Task.Run(async() => await sut.ExecuteAsync(parameters), cancelSource.Token); cancelSource.Cancel(); Assert.Equal(startState, sale.State); } }
public void Execute_transitions_when_matched_superState() { var stateMachine = getStateMachine(); var openStateConfig = stateMachine.ConfigureState(SaleState.Open); stateMachine.ConfigureState(SaleState.ChangeDue).MakeSubstateOf(openStateConfig); var sut = new StateTransitionAutoDynamic <Sale, SaleState, SaleEvent>(stateMachine , SaleState.Open , _ => SaleState.Complete , SaleState.Open , "autoComplete" , priority: 1); var testSale = new Sale(saleID: 2) { State = SaleState.ChangeDue }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, testSale); var previousResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay, SaleState.Open, SaleState.Open, SaleState.ChangeDue, "previousTransition"); var result = sut.Execute(parameters, previousResult); Assert.True(result.WasTransitioned); Assert.Equal("autoComplete", result.LastTransitionName); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.ChangeDue, SaleState.ChangeDue); Assert.Equal(SaleState.Open, result.StartingState); Assert.Equal(SaleState.Complete, testSale.State); }
public async Task ExecuteEntryActionAsync_does_not_execute_if_cancelled() { var sale = new Sale(saleId: 96) { State = SaleState.ChangeDue }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay , SaleState.Open , SaleState.Open , SaleState.ChangeDue , "lastTransitionName"); var stateMachine = new StateMachine <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var sut = new StateConfiguration <Sale, SaleState, SaleEvent>(SaleState.ChangeDue, stateMachine); var entryActionFromOpenFired = false; sut.AddEntryAction((sale1, _) => { entryActionFromOpenFired = true; return(Task.CompletedTask); }); using var cancelSource = new CancellationTokenSource(); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancelSource.Token); cancelSource.Cancel(); await sut.ExecuteEntryActionAsync(parameters, transitionResult); Assert.False(entryActionFromOpenFired); }
public void ValidateAction_WhenValidValuesAreEmpty_TextOrCustomChoiceIsPopulated() { // Arrange var defaultText = "Default Text"; InitializeChoicePropertyChangeAction(); _propertyChangeAction.PropertyValue = defaultText; _executionParameters = new ExecutionParameters( 1, new VersionControlArtifactInfo(), null, _customPropertyTypes, _saveRepositoryMock.Object, null, null, new List <IPropertyValidator>(), _reuseValidatorMock.Object); // Act var result = _propertyChangeAction.ValidateAction(_executionParameters); var propertyLiteValue = _propertyChangeAction.PropertyLiteValue; // Assert Assert.IsNull(result); Assert.AreEqual(propertyLiteValue.TextOrChoiceValue, defaultText); }
public async void ExecuteAsync_transitions_when_matched() { var stateMachine = getStateMachine(); var sut = new StateTransitionAutoDynamicAsync <Sale, SaleState, SaleEvent>(stateMachine , SaleState.Open , _ => SaleState.Complete , SaleState.ChangeDue , "autocomplete" , priority: 1); var testSale = new Sale(saleID: 2) { State = SaleState.Open }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, testSale); var previousResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay, SaleState.Open, SaleState.Open, SaleState.ChangeDue, "previousTransition"); var result = await sut.ExecuteAsync(parameters, previousResult); Assert.True(result.WasTransitioned); Assert.Equal("autocomplete", result.LastTransitionName); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.Complete, SaleState.Complete); Assert.Equal(SaleState.ChangeDue, SaleState.ChangeDue); Assert.Equal(SaleState.Open, result.StartingState); Assert.Equal(SaleState.Complete, testSale.State); }
public void ExecuteAutoTransition_executes_AutoTransition_without_previous_state() { var sale = new Sale(saleID: 96) { State = SaleState.ChangeDue }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.ChangeGiven , SaleState.Open , SaleState.ChangeDue , SaleState.ChangeDue , "lastTransitionName"); var stateMachine = new StateMachine <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var sut = new StateConfiguration <Sale, SaleState, SaleEvent>(SaleState.ChangeDue, stateMachine); sut.AddAutoForwardTransition(SaleEvent.ChangeGiven, SaleState.Complete, sale1 => true); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.ChangeGiven, sale); var autoTransitionResult = sut.ExecuteAutoTransition(parameters, transitionResult); Assert.True(autoTransitionResult.WasTransitioned); Assert.Equal(SaleState.Complete, sale.State); Assert.Equal(SaleState.Complete, autoTransitionResult.CurrentState); Assert.Equal(SaleState.ChangeDue, autoTransitionResult.PreviousState); Assert.Equal(SaleState.Open, autoTransitionResult.StartingState); }
public async Task ExecuteAsync_doesnt_send_notification_if_no_state_change() { var sut = new StateTransitionDynamicParameterizedAsync <Sale, SaleState, SaleEvent, string>( stateAccessor: sale => sale.State , stateMutator: (sale, newState) => sale.State = newState , stateFuncAsync: (sale, stringParam, cancelToken) => Task.FromResult(SaleState.Open) , name: "test" , priority: 1); var notificationReceived = false; StateTransitionDynamicAsync <Sale, SaleState, SaleEvent> .OnTransitionedEvent += (sale, _) => notificationReceived = true; using (var cancellationSource = new CancellationTokenSource()) { var sale = new Sale(saleID: 87) { State = SaleState.Open }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancellationSource.Token, "request"); await sut.ExecuteAsync(parameters); Assert.False(notificationReceived); } }
/// <summary> /// Executes demo live tests. /// </summary> internal static void RunLiveTests7() { // set package execution parameters eg. variables, connections var parameters = new ExecutionParameters(); // add variables and their values to be set when the package has been loaded parameters.AddProjectConnectionString("Customers Src", Constants.CustomersFileSource); parameters.AddProjectParameter("ConvertDestinationPath", Constants.CustomersFileConverted); parameters.AddProjectParameter("DestinationPath", Constants.CustomersFileDestination); parameters.AddProjectParameter("SourcePath", Constants.CustomersFileSource); // create engine for live testing var engine = EngineFactory.GetClassInstance <ILiveTestEngine>(); // load packages and relate them to the logical group - repository const string repositoryName = "DEMO5"; int cnt = engine.LoadPackages(repositoryName, Constants.PathToIspac); // load live tests from the current assembly engine.LoadRepositoryActions(repositoryName); // set execution parameters engine.SetExecutionParameters(parameters); // execute the package and attach live tests engine.ExecuteLiveTestsWithGui(repositoryName, "Main.dtsx"); }
public async Task ExecuteAsync_transitions_based_on_StateFuncAsync() { var sut = new StateTransitionDynamicParameterizedAsync <Sale, SaleState, SaleEvent, string>( stateAccessor: sale => sale.State , stateMutator: (sale, newState) => sale.State = newState , stateFuncAsync: (sale, stringParam, cancelToken) => Task.FromResult(SaleState.Complete) , name: "test" , priority: 1); using (var cancellationSource = new CancellationTokenSource()) { var sale = new Sale(saleID: 87) { State = SaleState.Open }; var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancellationSource.Token, "request"); var result = await sut.ExecuteAsync(parameters); Assert.Equal(SaleState.Complete, sale.State); Assert.Equal(SaleState.Complete, result.CurrentState); Assert.Equal(SaleState.Open, result.PreviousState); Assert.False(result.WasCancelled); } }
public void ExecuteAsync_ConditionAsync_can_be_cancelled() { const SaleState startState = SaleState.Open; var sale = new Sale(saleID: 66) { State = startState }; var sut = new StateTransitionAutoFallbackParameterizedAsync <Sale, SaleState, SaleEvent, string>( getStateMachine() , startState , SaleState.Complete , SaleState.Open , conditionAsync: (_, stringParam, cancellationToken) => { Task.Delay(millisecondsDelay: 999999, cancellationToken: cancellationToken); return(Task.FromResult(!cancellationToken.IsCancellationRequested)); } , name: "test" , priority: 1); using (var cancelSource = new CancellationTokenSource()) { var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancellationToken: cancelSource.Token); Task.Run(async() => await sut.ExecuteAsync(parameters, currentResult: null)); cancelSource.Cancel(); Assert.Equal(startState, sale.State); } }
private void InitializeNumberPropertyChangeAction() { _propertyChangeAction = new PropertyChangeAction() { InstancePropertyTypeId = DefaultNumberInstancePropertyTypeId, PropertyValue = DefaultNumberValue }; _customPropertyTypes = new List <WorkflowPropertyType>() { new NumberPropertyType() { InstancePropertyTypeId = DefaultNumberInstancePropertyTypeId, PrimitiveType = PropertyPrimitiveType.Number } }; _executionParameters = new ExecutionParameters( 1, new VersionControlArtifactInfo(), null, _customPropertyTypes, _saveRepositoryMock.Object, null, null, new List <IPropertyValidator>(), _reuseValidatorMock.Object); }
public async Task ExecuteAutoTransitionAsync_executes_AutoTransition_for_superState() { var sale = new Sale(saleID: 96) { State = SaleState.ChangeDue }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay , SaleState.Open , SaleState.Open , SaleState.ChangeDue , "lastTransitionName"); var stateMachine = new StateMachineAsync <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); IStateConfigurationAsyncInternal <Sale, SaleState, SaleEvent> openState = stateMachine.ConfigureState(SaleState.Open) as IStateConfigurationAsyncInternal <Sale, SaleState, SaleEvent>; IStateConfigurationAsyncInternal <Sale, SaleState, SaleEvent> changeDueState = stateMachine.ConfigureState(SaleState.ChangeDue) as IStateConfigurationAsyncInternal <Sale, SaleState, SaleEvent>; changeDueState.AddSuperState(openState); openState.AddAutoForwardTransition(SaleEvent.ChangeGiven, SaleState.Complete, (sale1, _) => Task.FromResult(result: true)); var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.ChangeGiven, sale); var autoTransitionResult = await changeDueState.ExecuteAutoTransitionAsync(parameters, transitionResult); Assert.True(autoTransitionResult.WasTransitioned); Assert.Equal(SaleState.Complete, sale.State); Assert.Equal(SaleState.Complete, autoTransitionResult.CurrentState); Assert.Equal(SaleState.ChangeDue, autoTransitionResult.PreviousState); Assert.Equal(SaleState.Open, autoTransitionResult.StartingState); }
public async Task ExecuteEntryActionAsync(ExecutionParameters <T, TTrigger> parameters, StateTransitionResult <TState, TTrigger> currentResult) { //If there's an entry action for a new super state, execute it first if (_superstate != null && !IsSubstateOf(currentResult.PreviousState)) { await _superstate.ExecuteEntryActionAsync(parameters, currentResult); } //Is there an action based on the new state? if (_previousStateEntryActions.TryGetValue(currentResult.PreviousState, out var action)) { if (parameters.CancellationToken.IsCancellationRequested) { return; } await action.Invoke(parameters.Context, parameters.CancellationToken).ConfigureAwait(continueOnCapturedContext: false); } //Is there an action for any entry? if (_defaultEntryAction != null) { if (parameters.CancellationToken.IsCancellationRequested) { return; } if (_defaultEntryAction != null) { await _defaultEntryAction.Invoke(parameters.Context, parameters.CancellationToken).ConfigureAwait(continueOnCapturedContext: false); } } }
public async Task ExecuteExitActionAsync_doesnt_execute_if_cancelled() { var sale = new Sale(saleID: 96) { State = SaleState.ChangeDue }; var transitionResult = new StateTransitionResult <SaleState, SaleEvent>(SaleEvent.Pay , SaleState.Open , SaleState.Open , SaleState.ChangeDue , "lastTransitionName"); var stateMachine = new StateMachineAsync <Sale, SaleState, SaleEvent>(sale1 => sale1.State, (sale1, newState) => sale1.State = newState); var openState = new StateConfigurationAsync <Sale, SaleState, SaleEvent>(SaleState.Open, stateMachine); var openExitActionFired = false; openState.AddExitAction((sale1, _) => { openExitActionFired = true; return(Task.CompletedTask); }); using (var cancelSource = new CancellationTokenSource()) { var parameters = new ExecutionParameters <Sale, SaleEvent>(SaleEvent.Pay, sale, cancelSource.Token); cancelSource.Cancel(); await openState.ExecuteExitActionAsync(parameters, transitionResult); } Assert.False(openExitActionFired); }
public async Task ExecuteExitActionAsync(ExecutionParameters <T, TTrigger> parameters , StateTransitionResult <TState, TTrigger> currentResult) { //Is there an action based on the new state? if (_nextStateExitActions.TryGetValue(currentResult.CurrentState, out var action)) { if (parameters.CancellationToken.IsCancellationRequested) { return; } await action.Invoke(parameters.Context, parameters.CancellationToken) .ConfigureAwait(continueOnCapturedContext: false); } //Is there an action for any exit? if (_defaultExitAction != null) { if (parameters.CancellationToken.IsCancellationRequested) { return; } if (_defaultExitAction != null) { await _defaultExitAction.Invoke(parameters.Context, parameters.CancellationToken) .ConfigureAwait(continueOnCapturedContext: false); } } }
/// <summary> /// Executes the test script object /// </summary> /// <param name="testScriptObject"></param> /// <param name="testCases"></param> private void executeTestScriptObject(ExecutionParameters executionParameters) { // Structuring this way as eventually the id or build might be a commmand line item for CI/CD if (TestProperties.GetProperty("TestRunId") == null) { // Not previously set, so create test run id and push to test properties. TestProperties.SetPropertyValue("TestRunId", DateTime.Now.Ticks.ToString()); } SuppressExecution = executionParameters._suppressExecution; _initialTestScriptObject = executionParameters._testScriptObject; // Must be a case or step... if (executionParameters._testProfile == null) { executionParameters._testProfile = new TestProfile(1, new TimeSpan(0, 0, 0), "VirtualUser"); } _mainExecutionThread = new Thread(new ParameterizedThreadStart(executeOnMainThread)); _mainExecutionThread.Name = "MainExecutionThread"; _mainExecutionThread.SetApartmentState(ApartmentState.STA); _mainExecutionThread.IsBackground = true; _mainExecutionThread.Start(executionParameters); }
public override StateTransitionResult <TState, TTrigger> Execute(ExecutionParameters <T, TTrigger> parameters , StateTransitionResult <TState, TTrigger> currentResult = null) { if (!(parameters.Request is TRequest typeSafeParam)) { throw new ArgumentException($"Expected a {typeof(TRequest).Name} parameter, but received a {parameters.Request?.GetType().Name ?? "null"}."); } if (currentResult != null && !parameters.CancellationToken.IsCancellationRequested && _startState.IsEqual(currentResult.PreviousState) && (_triggerState.IsEqual(currentResult.CurrentState) || _stateMachine.IsInState(parameters.Context, _triggerState))) { StateMutator(parameters.Context, _stateFunction(parameters.Context, typeSafeParam)); var transitioned = !StateAccessor(parameters.Context).IsEqual(_triggerState); var result = GetFreshResult(parameters , currentResult , currentResult.StartingState , wasCancelled: false , transitionDefined: true , conditionMet: transitioned); return(result); } return(GetFreshResult(parameters , currentResult , StateAccessor(parameters.Context) , wasCancelled: parameters.CancellationToken.IsCancellationRequested , transitionDefined: true , conditionMet: false)); }
private async Task <ScriptEvaluation> ExecuteScriptAsync(Script script, ExecutionParameters parameters) { var interpreter = _interpreterFactory.GetInterpreter(script.Language); var result = await interpreter.ExecuteAsync(script.Body, parameters); return(result); }
/// <inheritdoc/> public async Task <ScriptEvaluation> ExecuteAsync(string body, ExecutionParameters parameters) { var scriptFilePath = await WriteScriptToFileAsync(body); ProcessStartInfo startInfo = GetProcessStartInfo(scriptFilePath); return(await RunProcessAsync(parameters, startInfo, scriptFilePath)); }