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));
}
