public StepTestRunner( IStepContext stepContext, Func <IStepContext, Task> body, ITest test, IMessageBus messageBus, Type scenarioClass, object[] constructorArguments, MethodInfo scenarioMethod, object[] scenarioMethodArguments, string skipReason, IReadOnlyList <BeforeAfterTestAttribute> beforeAfterAttributes, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base( test, messageBus, scenarioClass, constructorArguments, scenarioMethod, scenarioMethodArguments, skipReason, beforeAfterAttributes, aggregator, cancellationTokenSource) { this.stepContext = stepContext; this.body = body; }
/// <summary> /// Immediately registers the <see cref="IDisposable"/> object for disposal /// after all steps in the current scenario have been executed. /// </summary> /// <typeparam name="T">The type of the object.</typeparam> /// <param name="obj">The object to be disposed.</param> /// <param name="stepContext">The execution context for the current step.</param> /// <returns>The object.</returns> public static T Using <T>(this T obj, IStepContext stepContext) where T : IDisposable { Guard.AgainstNullArgument("stepContext", stepContext); stepContext.Using(obj); return(obj); }
#pragma warning disable IDE0060 // Remove unused parameter 'text' if it is not part of a shipped public API public void UsingMetadata(string text, IStepContext stepContext, IStep step, IScenario scenario) #pragma warning restore IDE0060 // Remove unused parameter 'text' if it is not part of a shipped public API { "When I execute a step".x(context => stepContext = context) .Teardown(context => context.AssertSame(stepContext)); "Then the step context contains metadata about the step".x(() => { step = stepContext.Step.AssertNotNull(); var stepDisplayName = step.DisplayName; stepDisplayName.AssertEqual($"Xwellbehaved.MetadataFeature.UsingMetadata(text: \"abc\") [01] ({StepType.Scenario}): When I execute a step"); }); "And the step contains metadata about the scenario".x(() => { scenario = step.Scenario.AssertNotNull(); var scenarioDisplayName = scenario.DisplayName; scenarioDisplayName.AssertEqual("Xwellbehaved.MetadataFeature.UsingMetadata(text: \"abc\")"); }); "And the step contains metadata about the scenario outline".x(() => { var scenarioScenarioOutline = scenario.ScenarioOutline; scenarioScenarioOutline.AssertNotNull(); scenarioScenarioOutline.DisplayName.AssertEqual("Xwellbehaved.MetadataFeature.UsingMetadata"); }); }
public void Execute(IStepContext context) { if (context == null) { throw new ArgumentNullException($"{nameof(context)}"); } var ctx = context.Parent; while (ctx.ProcessingStep.GetType().FullName != typeof(ExecutiveOffice.EDT.FileOps.Steps.From.From).FullName) { if (ctx.Parent == null) { return; // throw new ArgumentOutOfRangeException($"Missing step {nameof(From.From)}"); } ctx = ctx.Parent; } IChannel channel = ChannelFactory.Create(ctx.FromSettings, ctx.WorkingDirectory); try { channel.Delete(ctx.Files); context.WorkingDirectory.DeleteWithContentIfExists(); }catch (Exception ex) { throw new ApplicationException("Exception occured during TearDown Delete", ex); } }
public StepContext(IStepContext previousStepContext) : this(previousStepContext.ProcessingStep, previousStepContext.Guid, previousStepContext.WorkingDirectory) { if (previousStepContext == null) { throw new ArgumentNullException($"{previousStepContext}"); } _previousFiles = previousStepContext.Files.ToList(); }
/// <summary> /// Immediately registers the <see cref="IDisposable"/> object for disposal /// after all steps in the current scenario have been executed. /// </summary> /// <typeparam name="T">The type of the object.</typeparam> /// <param name="disposable">The object to be disposed.</param> /// <param name="stepContext">The execution context for the current step.</param> /// <returns>The object.</returns> public static T Using <T>(this T disposable, IStepContext stepContext) where T : IDisposable { Guard.AgainstNullArgument(nameof(stepContext), stepContext); stepContext.Using(disposable); return(disposable); }
public void Execute(IStepContext context) { context.WorkingDirectory.Create(); IChannel channel = ChannelFactory.Create(_settings, context.WorkingDirectory); var processedFiles = channel.Copy(); context.Attach(processedFiles); }
public StepInvoker( IStepContext stepContext, Func <IStepContext, Task> body, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) { this.stepContext = stepContext; this.body = body; this.aggregator = aggregator ?? throw new ArgumentNullException(nameof(aggregator)); this.cancellationTokenSource = cancellationTokenSource ?? throw new ArgumentNullException(nameof(cancellationTokenSource)); }
public void Execute(IStepContext context) { var compressor = new Processors.Compression.ZipFactory(_settings).Get(); foreach (var file in context.Parent.Files) { var uncompressedFiles = compressor.Decompress(file, context.WorkingDirectory); context.Attach(uncompressedFiles); } }
public IStepContext Execute(Unity.OperationContext operationContext, IStepContext previousStepContext) { if ((this.Skip != null) && this.Skip(operationContext)) { return(null); } this.OperationContext = operationContext; this.PreviousStepContext = previousStepContext; this.OperationContext = null; this.PreviousStepContext = null; return(this.Execute()); }
public AggregationRoot(string identifier) { _guid = Guid.NewGuid(); _identifier = string.IsNullOrEmpty(identifier) ? throw new ArgumentNullException($"{identifier}") : identifier; AttachWorkingDirectory(); _emptyStepContext = new StepContext(new Init(), _guid, _workingDirectory); _contexts.Push(_emptyStepContext); }
public void Execute() { OperationContext operationContext = new OperationContext(); IStepContext previousStepContext = null; using (List <Step> .Enumerator enumerator = this.steps.GetEnumerator()) { while (enumerator.MoveNext()) { previousStepContext = enumerator.Current.Execute(operationContext, previousStepContext); } } }
public StepInvoker( IStepContext stepContext, Func <IStepContext, Task> body, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) { Guard.AgainstNullArgument(nameof(aggregator), aggregator); Guard.AgainstNullArgument(nameof(cancellationTokenSource), cancellationTokenSource); this.stepContext = stepContext; this.body = body; this.aggregator = aggregator; this.cancellationTokenSource = cancellationTokenSource; }
public void UsingMetadata(string text, IStepContext stepContext, IStep step, IScenario scenario) { "When I execute a step" .x(c => stepContext = c) .Teardown(c => Assert.Same(stepContext, c)); "Then the step context contains metadata about the step" .x(() => Assert.Equal("Xbehave.Test.MetadataFeature.UsingMetadata(text: \"abc\") [01] When I execute a step", (step = stepContext.Step)?.DisplayName)); "And the step contains metadata about the scenario" .x(() => Assert.Equal("Xbehave.Test.MetadataFeature.UsingMetadata(text: \"abc\")", (scenario = step.Scenario)?.DisplayName)); "And the step contains metadata about the scenario outline" .x(() => Assert.Equal("Xbehave.Test.MetadataFeature.UsingMetadata", scenario.ScenarioOutline?.DisplayName)); }
public void Execute(IStepContext context) { DirectoryInfo flushDirectory = context.WorkingDirectory.CreateSubdirectory("Flush"); context.Attach(context.PreviousFiles); //TODO: fix To channel + channel factory to be able to accept IEnumerable<FileInfo> instead of DirectoryInfo foreach (var file in context.PreviousFiles) { file.CopyTo(Path.Combine(flushDirectory.FullName, file.Name)); } IChannel channel = ChannelFactory.Create(_settings, flushDirectory); channel.Copy(); }
public void Test_DeserializeReplayStep_WithoutObservation() { // Arrange string expectedEventId = "my_experiment-t1-n10-f2-a4-0-0"; string expectedContext = PrepareJson("{ \"GUser\":{\"f_int\":0,\"f_float\":0.5,\"f_str_0\":\"value_0\",\"f_str_1\":\"value_1\"}, \"_multi\": [ { \"TAction\":{\"a_f_0\":\"value_0\",\"a_f_1\":\"value_1\"}},{ \"TAction\":{\"a_f_0\":\"value_1\",\"a_f_1\":\"value_2\"}},{ \"TAction\":{\"a_f_0\":\"value_2\",\"a_f_1\":\"value_3\"}},{ \"TAction\":{\"a_f_0\":\"value_3\",\"a_f_1\":\"value_4\"}}] }"); string expectedObservation = null; const string dsJsonWithObservation = "{\"_label_cost\":-0,\"_label_probability\":0.25,\"_label_Action\":1,\"_labelIndex\":0,\"Version\":\"1\",\"EventId\":\"my_experiment-t1-n10-f2-a4-0-0\",\"a\":[1,2,3,4],\"c\":{ \"GUser\":{\"f_int\":0,\"f_float\":0.5,\"f_str_0\":\"value_0\",\"f_str_1\":\"value_1\"}, \"_multi\": [ { \"TAction\":{\"a_f_0\":\"value_0\",\"a_f_1\":\"value_1\"}},{ \"TAction\":{\"a_f_0\":\"value_1\",\"a_f_1\":\"value_2\"}},{ \"TAction\":{\"a_f_0\":\"value_2\",\"a_f_1\":\"value_3\"}},{ \"TAction\":{\"a_f_0\":\"value_3\",\"a_f_1\":\"value_4\"}}] },\"p\":[0.250000,0.250000,0.250000,0.250000],\"VWState\":{\"m\":\"N/A\"}}"; // Act IStepContext <string> stepContext = ReplayStepProvider.DeserializeReplayStep(dsJsonWithObservation); string actualObservation = stepContext.GetOutcome(0, new ActionProbability[0]); Assert.AreEqual(expectedEventId, stepContext.EventId, $"{nameof(stepContext.EventId)} is not properly deserialized."); Assert.AreEqual(expectedContext, stepContext.DecisionContext, $"{nameof(stepContext.DecisionContext)} is not properly deserialized."); Assert.AreEqual(expectedObservation, actualObservation, $"Observation is not properly deserialized."); }
public void UsingMetadata( string text, IStepContext stepContext, IStep step, IScenario scenario, IXunitTestCase scenarioOutline) { "When I execute a step" .f(c => stepContext = c); "Then the step context contains metadata about the step" .f(() => (step = stepContext.Step.Should().NotBeNull().And.Subject.As <IStep>()) .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata(text: \"abc\") [01] When I execute a step")); "And the step contains metadata about the scenario" .f(() => (scenario = step.Scenario.Should().NotBeNull().And.Subject.As <IScenario>()) .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata(text: \"abc\")")); "And the step contains metadata about the scenario outline" .f(() => scenario.ScenarioOutline.Should().NotBeNull().And.Subject.As <IXunitTestCase>() .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata")); }
public void UsingMetadata( string text, IStepContext stepContext, IStep step, IScenario scenario, IXunitTestCase scenarioOutline) { "When I execute a step" .f(c => stepContext = c); "Then the step context contains metadata about the step" .f(() => (step = stepContext.Step.Should().NotBeNull().And.Subject.As<IStep>()) .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata(text: \"abc\") [01] When I execute a step")); "And the step contains metadata about the scenario" .f(() => (scenario = step.Scenario.Should().NotBeNull().And.Subject.As<IScenario>()) .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata(text: \"abc\")")); "And the step contains metadata about the scenario outline" .f(() => scenario.ScenarioOutline.Should().NotBeNull().And.Subject.As<IXunitTestCase>() .DisplayName.Should().Be("Xbehave.Test.Acceptance.MetadataFeature.UsingMetadata")); }
/// <summary> /// Immediately registers the <see cref="IDisposable"/> object for disposal after all /// steps in the current scenario have been executed. /// </summary> /// <typeparam name="T">The <see cref="IDisposable"/> object.</typeparam> /// <param name="disposable">The object to be disposed.</param> /// <param name="stepContext">The execution context for the current step.</param> /// <returns>The object.</returns> public static T Using <T>(this T disposable, IStepContext stepContext) where T : IDisposable { //Guard.AgainstNullArgument(nameof(stepContext), stepContext); //stepContext.Using(disposable); #if DEBUG //// TODO: TBD: not sure just what exactly is going on with this... //Validation.Requires.NotNull(stepContext, nameof(stepContext)).Using(disposable); stepContext.RequiresNotNull(nameof(stepContext)).Using(disposable); #else // Which, we "do", in DEBUG mode. #pragma warning disable CA1062 // ...validate parameter 'name' is non-null before using it... stepContext.Using(disposable); #pragma warning restore CA1062 // ...validate parameter 'name' is non-null before using it... #endif return(disposable); }
public StepInvoker( IStepContext stepContext , Func <IStepContext, Task> body , ExceptionAggregator aggregator , CancellationTokenSource cancellationTokenSource) { //Guard.AgainstNullArgument(nameof(aggregator), aggregator); //Guard.AgainstNullArgument(nameof(cancellationTokenSource), cancellationTokenSource); #if DEBUG aggregator.RequiresNotNull(nameof(aggregator)); cancellationTokenSource.RequiresNotNull(nameof(cancellationTokenSource)); #endif // TODO: TBD: #3 MWP 2020-07-01 03:15:09 PM / should we validate the other bits? this._stepContext = stepContext; this._body = body; this._aggregator = aggregator; this._cancellationTokenSource = cancellationTokenSource; }
public StepContext(IStepContext parentStepContext, IStep processingStep) : this(processingStep, parentStepContext.Guid, parentStepContext.WorkingDirectory, parentStepContext.FromSettings) { _parent = parentStepContext ?? throw new ArgumentNullException($"{parentStepContext}"); }
/// <summary> /// Immediately registers the <see cref="IDisposable"/> object for disposal /// after all steps in the current scenario have been executed. /// </summary> /// <typeparam name="T">The type of the object.</typeparam> /// <param name="disposable">The object to be disposed.</param> /// <param name="stepContext">The execution context for the current step.</param> /// <returns>The object.</returns> public static T Using <T>(this T disposable, IStepContext stepContext) where T : IDisposable { _ = (stepContext?.Using(disposable)); return(disposable); }
private void Step <TOutcome>(RunContext runContext, IOutcomeReporter <TOutcome> outcomeReporter, IStepContext <TOutcome> step) { string eventId = step.EventId; TOutcome outcome = default(TOutcome); if (loopKind == LoopKind.Slates) { if (!liveModel.TryRequestMultiSlotDecision(eventId, step.SlatesContext, runContext.MultiSlotResponseContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } int[] actions = runContext.MultiSlotResponseContainer.Select(slot => slot.ActionId).ToArray(); float[] probs = runContext.MultiSlotResponseContainer.Select(slot => slot.Probability).ToArray(); outcome = step.GetSlatesOutcome(actions, probs); if (outcome == null) { return; } } else if (loopKind == LoopKind.CA) { if (!liveModel.TryRequestContinuousAction(eventId, step.ContinuousActionContext, runContext.ContinuousActionContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } float action = runContext.ContinuousActionContainer.ChosenAction; float pdfValue = runContext.ContinuousActionContainer.ChosenActionPdfValue; outcome = step.GetContinuousActionOutcome(action, pdfValue); if (outcome == null) { return; } } else if (loopKind == LoopKind.CCB) { if (!liveModel.TryRequestDecision(step.DecisionContext, runContext.DecisionResponseContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } // TODO: Populate actionProbs. Currently GetOutcome() just returns a fixed outcome value, so the values of actionProbs don't matter. ActionProbability[] actionProbs = new ActionProbability[runContext.DecisionResponseContainer.Count]; foreach (var slot in runContext.DecisionResponseContainer) { outcome = step.GetOutcome(slot.ActionId, actionProbs); if (!outcomeReporter.TryQueueOutcomeEvent(runContext, slot.SlotId, outcome)) { this.SafeRaiseError(runContext.ApiStatusContainer); } } return; } else if (loopKind == LoopKind.CCBv2) { if (!liveModel.TryRequestMultiSlotDecisionDetailed(eventId, step.DecisionContext, runContext.MultiSlotResponseDetailedContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } foreach (var slot in runContext.MultiSlotResponseDetailedContainer) { outcome = step.GetOutcome(slot.ChosenAction, slot); if (!outcomeReporter.TryQueueOutcomeEvent(runContext, eventId, slot.SlotId, outcome)) { this.SafeRaiseError(runContext.ApiStatusContainer); } } return; } else { if (!liveModel.TryChooseRank(eventId, step.DecisionContext, runContext.ResponseContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } long actionIndex = -1; if (!runContext.ResponseContainer.TryGetChosenAction(out actionIndex, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } outcome = step.GetOutcome(actionIndex, runContext.ResponseContainer.AsEnumerable()); if (outcome == null) { return; } } if (!outcomeReporter.TryQueueOutcomeEvent(runContext, eventId, outcome)) { this.SafeRaiseError(runContext.ApiStatusContainer); } }
private void Step <TOutcome>(RunContext runContext, IOutcomeReporter <TOutcome> outcomeReporter, IStepContext <TOutcome> step) { string eventId = step.EventId; if (!liveModel.TryChooseRank(eventId, step.DecisionContext, runContext.ResponseContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } long actionIndex = -1; if (!runContext.ResponseContainer.TryGetChosenAction(out actionIndex, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } TOutcome outcome = step.GetOutcome(actionIndex, runContext.ResponseContainer.AsEnumerable()); if (outcome == null) { return; } if (!outcomeReporter.TryQueueOutcomeEvent(runContext, eventId, outcome)) { this.SafeRaiseError(runContext.ApiStatusContainer); } }
private void Step <TOutcome>(RunContext runContext, IOutcomeReporter <TOutcome> outcomeReporter, IStepContext <TOutcome> step) { string eventId = step.EventId; TOutcome outcome = default(TOutcome); if (loopKind == LoopKind.Slates) { if (!liveModel.TryRequestMultiSlotDecision(eventId, step.SlatesContext, runContext.SlatesContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } int[] actions = runContext.SlatesContainer.Select(slot => slot.ActionId).ToArray(); float[] probs = runContext.SlatesContainer.Select(slot => slot.Probability).ToArray(); outcome = step.GetSlatesOutcome(actions, probs); if (outcome == null) { return; } } else if (loopKind == LoopKind.CA) { if (!liveModel.TryRequestContinuousAction(eventId, step.ContinuousActionContext, runContext.ContinuousActionContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } float action = runContext.ContinuousActionContainer.ChosenAction; float pdfValue = runContext.ContinuousActionContainer.ChosenActionPdfValue; outcome = step.GetContinuousActionOutcome(action, pdfValue); if (outcome == null) { return; } } else { if (!liveModel.TryChooseRank(eventId, step.DecisionContext, runContext.ResponseContainer, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } long actionIndex = -1; if (!runContext.ResponseContainer.TryGetChosenAction(out actionIndex, runContext.ApiStatusContainer)) { this.SafeRaiseError(runContext.ApiStatusContainer); } outcome = step.GetOutcome(actionIndex, runContext.ResponseContainer.AsEnumerable()); if (outcome == null) { return; } } if (!outcomeReporter.TryQueueOutcomeEvent(runContext, eventId, outcome)) { this.SafeRaiseError(runContext.ApiStatusContainer); } }
public void Execute(IStepContext context) { }
public void Execute(IStepContext context) { throw new NotImplementedException(); }