public void GetStateBaseSteps_StateFromSource_ReturnsStepsOrEmptyList(
Dictionary <string, List <BaseStep> > addingStates,
State.StateType selectedState, List <BaseStep> expectedSteps,
BaseOperation customizableOper)
{
FillBaseOperationStatesWithReset(customizableOper, addingStates);
List <BaseStep> actualSteps = customizableOper
.GetStateBaseSteps(selectedState);
Assert.Multiple(() =>
{
for (int stepId = 0; stepId < actualSteps.Count; stepId++)
{
BaseStep expectedStep = expectedSteps[stepId];
BaseStep actualStep = actualSteps[stepId];
bool areEqual =
expectedStep.DefaultPosition ==
actualStep.DefaultPosition &&
expectedStep.LuaName == actualStep.LuaName &&
expectedStep.Name == actualStep.Name &&
expectedStep.Owner == actualStep.Owner;
Assert.IsTrue(areEqual);
}
});
}
public void TestPosemasterStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("Joey celebrate");
Assert.AreEqual(typeof(PoseMasterStep), step.GetType());
}
public void TestMoveToPositionStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("Joey => Lucy");
Assert.AreEqual(typeof(MoveToPositionStep), step.GetType());
}
public void TestSpeechBubbleCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("Joey say \"Citan told me all about your story. Do you want to talk about it? Why didn't you tell me? It sounds pretty rough.\"");
Assert.AreEqual(typeof(SpeechBubble), step.GetType());
}
public void TestWaitStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("wait 1000");
Assert.AreEqual(typeof(WaitStep), step.GetType());
}
public void TestTurnVectorStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("Joey turn south");
Assert.AreEqual(typeof(TurnVectorStep), step.GetType());
}
public void TestCamTargetStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("cam => Joey");
Assert.AreEqual(typeof(CameraTarget), step.GetType());
}
public void TerminateThrowsTerminateWorkflowException()
{
// Arrange
var step = new BaseStep();
// Actsert
Assert.Throws <TerminateWorkflowException>(() => step.Terminate());
}
public void TestLoadSceneStep()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("load_scene test_scene");
Assert.AreEqual(typeof(LoadSceneStep), step.GetType());
Assert.IsTrue((step as LoadSceneStep).SceneName == "test_scene");
}
public void TestFadeScreenStep()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("yield banana cherry");
Assert.AreEqual(typeof(YieldStep), step.GetType());
Assert.IsTrue((step as YieldStep).IDs.Contains("banana"));
Assert.IsTrue((step as YieldStep).IDs.Contains("cherry"));
}
public static void StartStep(BaseStep nextStep)
{
instance.CurrentStep.gameObject.SetActive(false);
instance.CurrentStep = nextStep;
if (nextStep)
{
instance.CurrentStep.gameObject.SetActive(true);
}
}
public void TestYieldStep()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep step = builder.BuildStep("fade => 1");
Assert.AreEqual(typeof(FadeScreenStep), step.GetType());
Assert.IsTrue((step as FadeScreenStep).Alpha == 1);
Assert.IsTrue((step as FadeScreenStep).SpeedType == SpeedType.Slow);
}
public async void ProcessForkWithException()
{
// Arrange
var settings = new StepSettings {
TrackStateChanges = true, AutoProgress = true
};
const string firstStepName = "first";
const string forkStepName = "fork";
const string secondStepName = "second";
const string exceptionalStepName = "exceptionalStep";
const string fourthStepName = "fourth";
var firstBaseStep = new BaseStep(firstStepName, settings);
var secondStepAsync = new AsyncStep(500, secondStepName);
var exceptionalStep = new ExceptionalStep(exceptionalStepName);
var fourthStepAsync = new AsyncStep(200, fourthStepName);
firstBaseStep.Fork(
name: forkStepName,
stepSettings: settings,
secondStepAsync,
exceptionalStep,
fourthStepAsync);
var expectedExecutionStarted = new[] { firstStepName, forkStepName, secondStepName, exceptionalStepName, fourthStepName };
var expectedExecutionCompletionOrder = new[] { firstStepName, fourthStepName, secondStepName };
var expectedFailedOrder = new[] { forkStepName, exceptionalStepName };
// Actssert
try
{
await firstBaseStep.Execute(_workflowState);
}
catch (WorkflowActionException <SimpleWorkflowState> ex)
{
var result = ex.WorkflowState;
var orderedByStarted = result.WorkflowChain.ToList().Select(x => x.StepName).ToArray();
var orderedByCompletion = result.WorkflowChain.ToList()
.Where(x => x.StepActivities.Any(y => y.Activity == StepActivityStages.ExecutionCompleted))
.OrderBy(x => x.StepActivities.FirstOrDefault(y => y.Activity == StepActivityStages.ExecutionCompleted).DateTimeOffset)
.Select(x => x.StepName)
.ToArray();
var failedStepNames = result.WorkflowChain.ToList()
.Where(x => x.StepActivities.Any(y => y.Activity == StepActivityStages.ExecutionFailed))
.Select(x => x.StepName)
.ToArray();
// Assert
Assert.True(expectedExecutionStarted.SequenceEqual(orderedByStarted));
Assert.True(expectedExecutionCompletionOrder.SequenceEqual(orderedByCompletion));
Assert.True(expectedFailedOrder.SequenceEqual(failedStepNames));
}
}
public void TestMoveInDirectionStepCreated()
{
var builder = new StepBuilder(new MockEntitySupplier());
BaseStep walk = builder.BuildStep("Joey => 100, 100");
BaseStep run = builder.BuildStep("Joey =>> 100, 100");
BaseStep sprint = builder.BuildStep("Joey =>>> 100, 100");
Assert.AreEqual(typeof(MoveAiInDirectionStep), walk.GetType());
Assert.AreEqual(typeof(MoveAiInDirectionStep), run.GetType());
Assert.AreEqual(typeof(MoveAiInDirectionStep), sprint.GetType());
}
public async void ExecuteCurrent()
{
// Arrange
var baseStepName = "base";
var originStep = new BaseStep(name: baseStepName);
// Act
var result = await originStep.Execute(_workflowState);
// Assert
Assert.Equal(_originalWorfklowState.MyInteger + 1, result.State.MyInteger);
}
private void SetStep(int index)
{
UpdateWizardState();
if (currentStep != null)
{
stepPanel.Controls.Remove(currentStep);
}
currentStepIndex = index;
currentStep = steps[index];
currentStep.ReportWizardState = currentState;
stepPanel.Controls.Add(currentStep);
currentStep.OnDisplay();
stepTitle.Text = currentStep.Title;
stepDescription.Text = currentStep.Description;
UpdateNavigationButtons();
}
public async void ProcessSequenceAfterAdd()
{
// Arrange
var settings = new StepSettings {
TrackStateChanges = true
};
var sequencer = new Sequencer <SimpleWorkflowState>(stepSettings: settings);
var firstStepName = "first";
var secondStepName = "second";
var firstStep = new BaseStep(name: firstStepName, settings);
var secondStep = new BaseStep(name: secondStepName, settings);
sequencer.AddStep(firstStep);
sequencer.AddStep(secondStep);
var expectedSequence = new List <Step <SimpleWorkflowState> > {
firstStep, secondStep
};
// Act
var result = await sequencer.Execute(_workflowState);
// Assert
Assert.Equal(_originalWorfklowState.MyInteger + 2, result.State.MyInteger);
Assert.Equal(3, result.WorkflowChain.Count);
Assert.True(expectedSequence.SequenceEqual(sequencer.GetSequence()));
var sequencerStepLink = result.WorkflowChain.First.Value;
var firstStepLink = result.WorkflowChain.First.Next.Value;
var secondStepLink = result.WorkflowChain.Last.Value;
Assert.Equal(sequencer.Id, sequencerStepLink.StepIdentifier);
var something = sequencerStepLink.GetUncompressedStateSnapshot <SimpleWorkflowState>();
Assert.Equal(0, sequencerStepLink.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
Assert.Equal(firstStep.Id, firstStepLink.StepIdentifier);
Assert.Equal(1, firstStepLink.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
Assert.Equal(secondStep.Id, secondStepLink.StepIdentifier);
Assert.Equal(2, secondStepLink.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
}
public async void WorkflowChainUpdatedWithSnapshot()
{
// Arrange
var baseStepName = "base";
var originStep = new BaseStep(name: baseStepName);
// Act
var result = await originStep.Execute(_workflowState);
var link = result.WorkflowChain.First.Value;
// Assert
Assert.Single(result.WorkflowChain);
Assert.Equal(baseStepName, link.StepName);
Assert.Equal(originStep.Id, link.StepIdentifier);
Assert.Equal(0, link.SequenceNumber);
Assert.Null(link.GetUncompressedStateSnapshot <SimpleWorkflowState>());
Assert.Equal(StepActivityStages.Executing, link.StepActivities.First().Activity);
Assert.Equal(StepActivityStages.ExecutionCompleted, link.StepActivities.Last().Activity);
}
public async void ProcessFork()
{
// Arrange
var settings = new StepSettings {
TrackStateChanges = true, AutoProgress = true
};
const string firstStepName = "first";
const string forkStepName = "fork";
const string secondStepName = "second";
const string thirdStepName = "third";
const string fourthStepName = "fourth";
var firstBaseStep = new BaseStep(firstStepName, settings);
var secondStepAsync = new AsyncStep(500, secondStepName);
var thirdStepAsync = new AsyncStep(0, thirdStepName);
var fourthStepAsync = new AsyncStep(200, fourthStepName);
firstBaseStep.Fork(
name: forkStepName,
stepSettings: settings,
secondStepAsync,
thirdStepAsync,
fourthStepAsync);
var expectedExecutionStarted = new[] { firstStepName, forkStepName, secondStepName, thirdStepName, fourthStepName };
var expectedExecutionCompletionOrder = new[] { firstStepName, thirdStepName, fourthStepName, secondStepName, forkStepName };
// Act
var result = await firstBaseStep.Execute(_workflowState);
var orderedByStarted = result.WorkflowChain.ToList().Select(x => x.StepName).ToArray();
var orderedByCompletion = result.WorkflowChain.ToList()
.OrderBy(x => x.StepActivities.FirstOrDefault(y => y.Activity == StepActivityStages.ExecutionCompleted).DateTimeOffset)
.Select(x => x.StepName)
.ToArray();
// Assert
Assert.True(expectedExecutionStarted.SequenceEqual(orderedByStarted));
Assert.True(expectedExecutionCompletionOrder.SequenceEqual(orderedByCompletion));
}
public void SetNextByType()
{
// Arrange
var baseStepName = "base";
var nextStepName = "next";
var originStep = new BaseStep(name: baseStepName);
var nextStep = new AnotherStepType(name: nextStepName);
var optionsStep = new BaseSelector();
// Act
var actualNextStep = originStep.SetNext(nextStep);
var actualOptionsStep = actualNextStep.SetNext(optionsStep);
// Assert
Assert.IsType <AnotherStepType>(actualNextStep);
Assert.Equal(nextStep, originStep.Next());
Assert.IsType <BaseSelector>(actualOptionsStep);
Assert.Equal(optionsStep, nextStep.Next());
}
private Step CreateStep(XmlReader reader, BaseStep lastStep)
{
var attributes = GetAttributes(reader);
var name = attributes.ContainsKey("name") ? attributes["name"] : "";
int repititions = 1;
if (attributes.ContainsKey("repititions"))
{
repititions = int.Parse(attributes["repititions"]);
}
Step step = new Step(name, DB.StatisticType.step, null, lastStep, repititions, statisticManager);
if (lastStep != null)
{
lastStep.AddNext(step);
}
return(step);
}
public void NextAndPreviousMethods()
{
// Arrange
var baseStepName = "base";
var previousStepName = "previous";
var nextStepName = "next";
var originStep = new BaseStep(name: baseStepName);
var previousStep = new BaseStep(name: previousStepName);
var nextStep = new BaseStep(name: nextStepName);
// Act
var actualNextStep = originStep.SetNext(nextStep);
var actualpreviousStep = originStep.SetPrevious(previousStep);
// Assert
Assert.Equal(nextStep, actualNextStep);
Assert.Equal(previousStep, actualpreviousStep);
Assert.Equal(nextStep, originStep.Next());
Assert.Equal(previousStep, originStep.Previous());
}
public async void SelectorSetsNext()
{
// Arrange
var selector = new BaseSelector();
var expectedOption = new BaseStep(name: "expectedOption");
var option = new BaseStep(name: "option");
var options = new List <Step <SimpleWorkflowState> >()
{
expectedOption, option
};
selector.SetOptions(options);
// Act
var result = await selector.Execute(_workflowState);
// Assert
Assert.Single(result.WorkflowChain);
Assert.Equal(_originalWorfklowState, result.State);
Assert.Equal(selector.Next(), expectedOption);
}
public async void WorkflowChainUpdated()
{
// Arrange
var baseStepName = "base";
var settings = new StepSettings {
TrackStateChanges = true
};
var originStep = new BaseStep(name: baseStepName, settings);
// Act
var result = await originStep.Execute(_workflowState);
var link = result.WorkflowChain.First.Value;
// Assert
Assert.Single(result.WorkflowChain);
Assert.Equal(baseStepName, link.StepName);
Assert.Equal(originStep.Id, link.StepIdentifier);
Assert.Equal(0, link.SequenceNumber);
Assert.Equal(_originalWorfklowState.MyInteger + 1, link.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
Assert.Equal(StepActivityStages.Executing, link.StepActivities.First().Activity);
Assert.Equal(StepActivityStages.ExecutionCompleted, link.StepActivities.Last().Activity);
}
public async void AutoProgressSetting()
{
// Arrange
var baseStepName = "base";
var nextStepName = "next";
var settings = new StepSettings()
{
AutoProgress = true, TrackStateChanges = true
};
var originStep = new BaseStep(name: baseStepName, stepSettings: settings);
var nextStep = new BaseStep(name: nextStepName, stepSettings: settings);
originStep.SetNext(nextStep);
// Act
var result = await originStep.Execute(_workflowState);
// Assert
Assert.Equal(_originalWorfklowState.MyInteger + 2, result.State.MyInteger);
Assert.Equal(2, result.WorkflowChain.Count);
var firstLink = result.WorkflowChain.First.Value;
var secondLink = result.WorkflowChain.Last.Value;
Assert.Equal(originStep.Id, firstLink.StepIdentifier);
Assert.Equal(1, firstLink.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
Assert.Equal(nextStep.Id, secondLink.StepIdentifier);
Assert.Equal(2, secondLink.GetUncompressedStateSnapshot <SimpleWorkflowState>().MyInteger);
Assert.Equal(StepActivityStages.Executing, firstLink.StepActivities.First().Activity);
Assert.Equal(StepActivityStages.ExecutionCompleted, firstLink.StepActivities.Last().Activity);
Assert.Equal(StepActivityStages.Executing, secondLink.StepActivities.First().Activity);
Assert.Equal(StepActivityStages.ExecutionCompleted, secondLink.StepActivities.Last().Activity);
}
public void StepMethods()
{
// Arrange
var step1 = new BaseStep("one");
var step2 = new BaseStep("two");
var step3 = new BaseStep("three");
var baseStepList = new List <Step <SimpleWorkflowState> > {
step1, step2, step3
};
var whileLoop = new WhileLoop <SimpleWorkflowState>();
// ActSert a lot because who cares...
whileLoop.SetSteps(baseStepList);
Assert.Equal(baseStepList, whileLoop.Steps);
whileLoop.ClearSteps();
Assert.Empty(whileLoop.Steps);
whileLoop.AddStep(step1);
Assert.Single(whileLoop.Steps);
Assert.Equal(step1, whileLoop.Steps.First());
}
public bool ShouldRetry(BaseStep step, int attempt)
{
return(attempt == 1);
}
/// <inheritdoc />
protected override Task <Result <int, IError> > Run(
IStateMonad stateMonad,
CancellationToken cancellationToken)
{
return(BaseStep.Run(stateMonad, cancellationToken));
}
public TimeLineStep(BaseStep step)
{
this.Step = step;
}
public bool ShouldRetry(BaseStep step, int attempt)
{
return(false);
}
