public Step(string name = null, StepSettings stepSettings = null, IClock clock = null) { Name = name ?? GetType().Name; Id = Guid.NewGuid().ToString("N"); _stepSettings = stepSettings; _clock = clock ?? new Clock(); }
public ForLoop( Func <T, Task <int> > setIterationCountAsync, string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings, steps) { _setIterationCountAsync = setIterationCountAsync; }
public WhileLoop( Func <T, bool> shouldContinue, string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings, steps) { _shouldContinue = shouldContinue; }
public Step(string name = null, string id = null, StepSettings stepSettings = null, IProcessor <T> processor = null, IClock clock = null) { Name = name ?? GetType().Name.ToString(); Id = id ?? Guid.NewGuid().ToString("N"); _processorSettings = stepSettings ?? new StepSettings(); _processor = processor; _clock = clock ?? new Clock(); }
public AsyncStep( int delayMs, string name = null, StepSettings stepSettings = null, IClock clock = null) : base(name, stepSettings, clock) { _delayMs = delayMs; }
/// <summary> /// Удаляет указанный этапа для редактирования /// </summary> private void DeleteStepSettings(object obj) { if (!(obj is StepSettings)) { return; } StepSettings.Remove(obj as StepSettings); }
public WhileLoop( Func <T, Task <bool> > shouldContinueAsync, string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings, steps) { _shouldContinueAsync = shouldContinueAsync; }
public ForLoop( Func <T, int> setIterationCount, string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings, steps) { _setIterationCount = setIterationCount; }
public void CopyProjects() { StepSettings settings = new StepSettings(new string[] { StepSettings.COPY_PROJECTS }); Assert.AreEqual(settings.DefaultSteps, settings.Steps); settings = new StepSettings(new string[] { StepSettings.COPY_PROJECTS, "destination path" }); Assert.AreEqual(Steps.CopyDirs, settings.Steps); }
protected Instruction( StepSettings stepSettings, MainWorkflowManager mainWorkflowManager, ILogger logger, WorkflowDataValidator[] workflowDataValidators) : base(stepSettings, logger, workflowDataValidators) { MainWorkflowManager = mainWorkflowManager; }
public ForLoop( int iterations, string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings, steps) { _iterationCount = iterations; }
/// <summary> /// Открыввает окно с параметрами этапа измерения /// </summary> private void AddStepSettings(object obj) { var stepViewModel = new StepSettingsViewModel(); if (WindowService.ShowDialog(stepViewModel) ?? false) { StepSettings.Add(stepViewModel.StepSettigs); } }
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 TestStep( TestStepDependency testStepDependency, StepSettings stepSettings, ILogger logger, IWorkflowManager workflowManager, IStepFactory stepFactory, WorkflowDataValidator[] workflowDataValidators) : base(stepSettings, logger, workflowManager, stepFactory, workflowDataValidators) { _testStepDependency = testStepDependency; }
public void InstructionHelper_IdentifiesTheFirstStep(StepSettings stepSettings) { var lines = new List <string> { "Step C must be finished before step A can begin.", "Step C must be finished before step F can begin.", }; var steps = new StepFactory(stepSettings).Create(lines); var instructionHelper = new InstructionHelper(); var result = instructionHelper.Order(steps); Assert.Equal('C', result.First()); }
/// <summary> /// Проверяет возможность удаления указанный этапа /// </summary> private bool CanDeleteStepSettings(object obj) { if (!(obj is StepSettings)) { return(false); } var step = obj as StepSettings; if (StepSettings.SelectedItem != step && StepSettings.Contains(step)) { return(true); } return(false); }
public void CompatibleSteps() { string[] compatibleSteps = new string[] { StepSettings.ENV_INIT, StepSettings.REMOVE_PROJECTS, StepSettings.GET_PROJECTS, StepSettings.BUILD_PROJECTS, StepSettings.TEST_PROJECTS, StepSettings.COLLECT_ARTIFATCS, StepSettings.COPY_PROJECTS, "destination path" }; StepSettings settings = new StepSettings(compatibleSteps); Assert.AreEqual(settings.AllSteps, settings.Steps); }
public void InstructionHelper_PicksNextStepAlpabeticallyFromAllAvailable(StepSettings stepSettings) { var lines = new List <string> { "Step C must be finished before step A can begin.", "Step C must be finished before step F can begin.", "Step A must be finished before step B can begin.", }; var steps = new StepFactory(stepSettings).Create(lines); var instructionHelper = new InstructionHelper(); var result = instructionHelper.Order(steps); Assert.Equal("CABF", result); }
public void InstructionHelper_TimeToAssemble_TwoWorkersSolvesThreeSteps(StepSettings stepSettings, WorkerSettings workerSettings) { stepSettings.DurationOffset = 0; workerSettings.WorkerCount = 2; var lines = new List <string> { "Step C must be finished before step B can begin.", "Step C must be finished before step F can begin.", }; var steps = new StepFactory(stepSettings).Create(lines); var instructionHelper = new InstructionHelper(); var result = instructionHelper.TimeToAssemble(steps, workerSettings.WorkerCount); Assert.Equal(9, result); }
public void Step_ParsesTwoLinesWithThreeSteps(StepSettings stepSettings) { var lines = new List <string> { "Step C must be finished before step A can begin.", "Step C must be finished before step F can begin.", }; var steps = new StepFactory(stepSettings).Create(lines); Assert.Equal(3, steps.Count); Assert.Contains(steps.First(x => x.Name == 'A').PrerequisiteSteps, x => x.Name == 'C'); Assert.Contains(steps.First(x => x.Name == 'F').PrerequisiteSteps, x => x.Name == 'C'); Assert.Contains(steps.First(x => x.Name == 'C').NextSteps, x => x.Name == 'A'); Assert.Contains(steps.First(x => x.Name == 'C').NextSteps, x => x.Name == 'F'); }
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 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 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); }
private void StepCollection_SelectionChanged(WSICollection <StepSettings> collection, ChangedEventArgs <StepSettings> args) { isDone = false; _step = collection.SelectedItem; //Установка текущего индекса в -1 означает, что достигли конца коллекции // или был вызван метод ResetSelection(), т.е. перезапустили этапы if (collection.SelectedIndex == -1) { isDone = true; return; } switch (collection.SelectedItem.Type) { //TODO: необходимо ли проверять на два этих типа? case StepType.NotAssigned: case StepType.Done: return; case StepType.Waiting: case StepType.Heating: _coeff = 1; break; case StepType.Cooling: _coeff = -1; break; } NextTemperature = _step.From; while (_coeff * NextTemperature < _coeff * CurrentTemperature) { NextTemperature += _coeff * _step.Step; } }
public void CollectArtifacts() { StepSettings settings = new StepSettings(new string[] { StepSettings.COLLECT_ARTIFATCS }); Assert.AreEqual(settings.DefaultSteps | Steps.CollectArtifacts, settings.Steps); }
protected Loop(string name = null, StepSettings stepSettings = null, List <Step <T> > steps = null) : base(name, stepSettings) { _steps = steps ?? new List <Step <T> >(); }
public static Fork <TState> Fork <TState>(this Step <TState> source, List <Step <TState> > steps, string name = null, StepSettings stepSettings = null) where TState : class { var fork = new Fork <TState>(steps, name, stepSettings); source.SetNextStep(fork); return(fork); }
public void DefaultSettings() { StepSettings settings = new StepSettings(null); Assert.AreEqual(settings.DefaultSteps, settings.Steps); }
public LoopStep(string name = null, StepSettings stepSettings = null, IClock clock = null) : base(name, stepSettings, clock) { }
public void BuildProjects() { StepSettings settings = new StepSettings(new string[] { StepSettings.BUILD_PROJECTS }); Assert.AreEqual(Steps.Build, settings.Steps); }
public void GetProjects() { StepSettings settings = new StepSettings(new string[] { StepSettings.GET_PROJECTS }); Assert.AreEqual(Steps.GetProjectsFromDXVCS, settings.Steps); }
public void RemoveProjects() { StepSettings settings = new StepSettings(new string[] { StepSettings.REMOVE_PROJECTS }); Assert.AreEqual(Steps.RemoveProjectsDirectories, settings.Steps); }
public static Fork <TState> Fork <TState>(this Step <TState> source, string name = null, StepSettings stepSettings = null, params Step <TState>[] steps) where TState : class { var fork = new Fork <TState>(name, stepSettings, steps); source.SetNextStep(fork); return(fork); }
public void RunTests() { StepSettings settings = new StepSettings(new string[] { StepSettings.TEST_PROJECTS }); Assert.AreEqual(Steps.RunTests, settings.Steps); }
public StepSettingsViewModel(StepSettings step) { StepSettigs = step; }
public async void TestAutomatedFlow() { // Arrange var firstStepName = "firstStepName"; var secondStepName = "secondStepName"; var thirdStepName = "thirdStepName"; var firstStepId = "firstStepId"; var secondStepId = "secondStepId"; var thirdStepId = "thirdStepId"; var stepSettings = new StepSettings() { AutoProgress = true }; var firstStep = new Step <SimpleWorkflowState>(name: firstStepName, id: firstStepId, stepSettings: stepSettings, processor: _testProcessor, clock: _mockClock.Object); var secondStep = new Step <SimpleWorkflowState>(name: secondStepName, id: secondStepId, stepSettings: stepSettings, processor: _testProcessor, clock: _mockClock.Object); var thirdStep = new Step <SimpleWorkflowState>(name: thirdStepName, id: thirdStepId, stepSettings: stepSettings, processor: _testProcessor, clock: _mockClock.Object); firstStep .SetNext(secondStep) .SetNext(thirdStep); var workflowState = new WorkflowState <SimpleWorkflowState>() { State = new SimpleWorkflowState() }; var expectedWorkflowChain = new LinkedList <WorkflowChainLink>(); var firstexpectedLink = new WorkflowChainLink() { StepIdentifier = firstStepId, StepName = firstStepName, SequenceNumber = 0, StepActivities = new List <StepActivity>() { new StepActivity(StepActivityStages.Executing, clock: _mockClock.Object), new StepActivity(StepActivityStages.ExecutionCompleted, clock: _mockClock.Object) } }; firstexpectedLink.SetStateSnapshot(1); var secondExpectedLink = new WorkflowChainLink() { StepIdentifier = secondStepId, StepName = secondStepName, SequenceNumber = 1, StepActivities = new List <StepActivity>() { new StepActivity(StepActivityStages.Executing, clock: _mockClock.Object), new StepActivity(StepActivityStages.ExecutionCompleted, clock: _mockClock.Object) } }; secondExpectedLink.SetStateSnapshot(2); var thirdExpectedLink = new WorkflowChainLink() { StepIdentifier = thirdStepId, StepName = thirdStepName, SequenceNumber = 2, StepActivities = new List <StepActivity>() { new StepActivity(StepActivityStages.Executing, clock: _mockClock.Object), new StepActivity(StepActivityStages.ExecutionCompleted, clock: _mockClock.Object) } }; thirdExpectedLink.SetStateSnapshot(3); expectedWorkflowChain.AddLast(firstexpectedLink); expectedWorkflowChain.AddLast(secondExpectedLink); expectedWorkflowChain.AddLast(thirdExpectedLink); var expectedWorkflowState = new WorkflowState <SimpleWorkflowState>() { State = new SimpleWorkflowState() { MyInteger = 3 }, WorkflowChain = expectedWorkflowChain }; // Act var result = await firstStep.Process(workflowState); // Assert Assert.Equal(expectedWorkflowState.State.MyInteger, result.State.MyInteger); var currentExpectedLink = expectedWorkflowChain.First; foreach (var resultLink in result.WorkflowChain) { Assert.Equal(JsonSerializer.Serialize(currentExpectedLink.Value), JsonSerializer.Serialize(resultLink)); currentExpectedLink = currentExpectedLink.Next; } }
public StepSettingsViewModel() { StepSettigs = new StepSettings(); }
public void EnvironmentInitialization() { StepSettings settings = new StepSettings(new string[] { StepSettings.ENV_INIT }); Assert.AreEqual(Steps.EnvironmentInitialization, settings.Steps); }