private void ScenarioSetup(ScenarioInfo scenarioInfo)
{
var tagsList = scenarioInfo.Tags.ToList();
scenarioInfo = new ScenarioInfo(scenarioInfo.Title, tagsList.ToArray());
testRunner.OnScenarioStart(scenarioInfo);
}
public void ShouldGetEmptyTagListByDefault()
{
var specInfo = new SpecInfo
{
Tags = { "foo" },
Name = "",
FileName = "",
IsFailed = false
};
var scenarioInfo = new ScenarioInfo
{
Tags = { "bar" },
Name = "",
IsFailed = false
};
var currentScenario = new ExecutionInfo
{
CurrentScenario = scenarioInfo,
CurrentSpec = specInfo
};
var currentExecutionInfo = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = currentScenario
};
var message = new Message
{
ScenarioExecutionStartingRequest = currentExecutionInfo,
MessageType = Message.Types.MessageType.ScenarioExecutionStarting,
MessageId = 0
};
var tags = AssertEx.ExecuteProtectedMethod <ExecutionStartingProcessor>("GetApplicableTags", message);
Assert.IsEmpty(tags);
}
public virtual IObjectContainer CreateScenarioContainer(IObjectContainer testThreadContainer, ScenarioInfo scenarioInfo)
{
if (testThreadContainer == null)
throw new ArgumentNullException(nameof(testThreadContainer));
var scenarioContainer = new ObjectContainer(testThreadContainer);
scenarioContainer.RegisterInstanceAs(scenarioInfo);
var contextManager = testThreadContainer.Resolve<IContextManager>();
var featureContext = contextManager.FeatureContext;
if (featureContext != null)
scenarioContainer.RegisterInstanceAs(featureContext);
scenarioContainer.ObjectCreated += obj =>
{
var containerDependentObject = obj as IContainerDependentObject;
if (containerDependentObject != null)
containerDependentObject.SetObjectContainer(scenarioContainer);
};
var runtimePluginEvents = testThreadContainer.Resolve<RuntimePluginEvents>();
runtimePluginEvents.RaiseCustomizeScenarioDependencies(scenarioContainer);
return scenarioContainer;
}
public void ShouldGetTagListFromScenarioAndSpec()
{
var specInfo = SpecInfo.CreateBuilder()
.AddTags("foo")
.SetName("")
.SetFileName("")
.SetIsFailed(false)
.Build();
var scenarioInfo = ScenarioInfo.CreateBuilder()
.AddTags("bar")
.SetName("")
.SetIsFailed(false)
.Build();
var currentScenario = ExecutionInfo.CreateBuilder()
.SetCurrentScenario(scenarioInfo)
.SetCurrentSpec(specInfo)
.Build();
var currentExecutionInfo = StepExecutionEndingRequest.CreateBuilder()
.SetCurrentExecutionInfo(currentScenario)
.Build();
var message = Message.CreateBuilder()
.SetStepExecutionEndingRequest(currentExecutionInfo)
.SetMessageType(Message.Types.MessageType.StepExecutionEnding)
.SetMessageId(0)
.Build();
var tags = AssertEx.ExecuteProtectedMethod <StepExecutionEndingProcessor>("GetApplicableTags", message).ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(2, tags.Count);
Assert.Contains("foo", tags);
Assert.Contains("bar", tags);
}
/// <summary>
/// 区切ったシナリオを細かく解析
/// </summary>
ScenarioInfo ScenarioAnalysis(string line)
{
ScenarioInfo scenario = new ScenarioInfo();
StringReader sr = new StringReader(line);
var message = new System.Text.StringBuilder();
string text;
while ((text = sr.ReadLine()) != null)
{
if (text.StartsWith("//") || string.IsNullOrEmpty(text))
{
//不必要な行
continue;
}
else if (text.StartsWith("@"))
{
//コマンドの行
ParseCommandInfo(text, scenario);
}
else
{
//セリフの行
message.Append(text + "\n");
}
}
if (message.Length != 0)
{
scenario.message = message.ToString();
}
return(scenario);
}
public ExecutionContext.Scenario ScenarioFrom(ScenarioInfo currentScenario)
{
return(currentScenario != null
? new ExecutionContext.Scenario(currentScenario.Name, currentScenario.IsFailed,
currentScenario.Tags.ToArray())
: new ExecutionContext.Scenario());
}
public void ShouldGetEmptyTagListByDefault()
{
var specInfo = SpecInfo.CreateBuilder()
.AddTags("foo")
.SetName("")
.SetFileName("")
.SetIsFailed(false)
.Build();
var scenarioInfo = ScenarioInfo.CreateBuilder()
.AddTags("bar")
.SetName("")
.SetIsFailed(false)
.Build();
var currentScenario = ExecutionInfo.CreateBuilder()
.SetCurrentScenario(scenarioInfo)
.SetCurrentSpec(specInfo)
.Build();
var currentExecutionInfo = ScenarioExecutionStartingRequest.CreateBuilder()
.SetCurrentExecutionInfo(currentScenario)
.Build();
var message = Message.CreateBuilder()
.SetScenarioExecutionStartingRequest(currentExecutionInfo)
.SetMessageType(Message.Types.MessageType.ScenarioExecutionStarting)
.SetMessageId(0)
.Build();
var tags = AssertEx.ExecuteProtectedMethod <ExecutionEndingProcessor>("GetApplicableTags", message);
Assert.IsEmpty(tags);
}
public void OnScenarioInitialize(ScenarioInfo scenarioInfo)
{
lock (Lock)
{
_engine.OnScenarioInitialize(scenarioInfo);
}
}
public StatisticsScenarioInfo GetStatisticsInfoForScenario(ScenarioBase scenario, ScenarioActionSource source)
{
if (scenario.SecuritySettings.IsAvailableForUser(source.User, source.Source, source.Action))
{
if (scenario is RemoteScenario remoteScenario)
{
try
{
if (!scenario.GetIsAvailable())
{
throw new ScenarioExecutionException(ScenarioExecutionError.NotAvailable);
}
var scenarioInfo = new ScenarioInfo();
scenarioInfo.ScenarioId = remoteScenario.RemoteScenarioId;
scenarioInfo.ValueType = scenario.ValueType;
var server = ClientFactory.GetServer(remoteScenario.Credentials);
var remoteScenarioInfo = server.GetStatisticsInfoForScenario(new Encrypted <ScenarioInfo>(scenarioInfo, remoteScenario.Credentials.SecretKey))
.Decrypt(remoteScenario.Credentials.SecretKey);
remoteScenarioInfo.ID = scenario.Id; //set current scenario id
remoteScenarioInfo.Name = scenario.Name;
return(remoteScenarioInfo);
}
catch (Exception e)
{
throw e;
}
}
else
{
return(_dataManager.GetInfo(scenario.Id, scenario.Name, ActionsDomain.Utils.GetValueTypeClassName(scenario.ValueType.GetType())));
}
}
throw new ScenarioExecutionException(ScenarioExecutionError.AccessDenied);
}
public void ShouldGetEmptyTagListByDefault()
{
var specInfo = new SpecInfo
{
Tags = { "foo" },
Name = "",
FileName = "",
IsFailed = false
};
var scenarioInfo = new ScenarioInfo
{
Tags = { "bar" },
Name = "",
IsFailed = false
};
var currentScenario = new ExecutionInfo
{
CurrentScenario = scenarioInfo,
CurrentSpec = specInfo
};
var tags = AssertEx.ExecuteProtectedMethod <ExecutionStartingProcessor>("GetApplicableTags", currentScenario);
Assert.IsEmpty(tags);
}
private void RunScenario(SpecFlowDocument gherkinDocument, Scenario scenario)
{
FeatureSetup(gherkinDocument);
var scenarioInfo = new ScenarioInfo(scenario.Name, scenario.Tags.GetTags().ToArray());
ScenarioSetup(scenarioInfo);
IEnumerable <SpecFlowStep> steps = scenario.Steps.Cast <SpecFlowStep>();
if (gherkinDocument.SpecFlowFeature.Background != null)
{
steps = gherkinDocument.SpecFlowFeature.Background.Steps.Cast <SpecFlowStep>().Concat(steps);
}
try
{
foreach (var step in steps)
{
Debug.WriteLine($"> Running {step.Keyword}{step.Text}");
ExecuteStep(step);
}
ScenarioCleanup(); // normally this is the point when the scenario errors are thrown
}
finally
{
ScenarioTearDown();
FeatureTearDown();
}
}
public void ShouldNotFetchDuplicateTags()
{
var specInfo = new SpecInfo
{
Tags = { "foo" },
Name = "",
FileName = "",
IsFailed = false
};
var scenarioInfo = new ScenarioInfo
{
Tags = { "foo" },
Name = "",
IsFailed = false
};
var currentScenario = new ExecutionInfo
{
CurrentSpec = specInfo,
CurrentScenario = scenarioInfo
};
var tags = AssertEx.ExecuteProtectedMethod <ScenarioExecutionStartingProcessor>("GetApplicableTags", currentScenario)
.ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(1, tags.Count);
Assert.Contains("foo", tags);
}
private void DisplayScenarioDetails(ScenarioInfo info)
{
this.scenarioNameText.text = I18N.Instance.Get(info.Data.NameKey);
DisplayMonsterTraits(info);
DisplayRewards(info);
}
public void ShouldGetTagListFromScenarioAndSpecAndIgnoreDuplicates()
{
var specInfo = new SpecInfo
{
Tags = { "foo" },
Name = "",
FileName = "",
IsFailed = false
};
var scenarioInfo = new ScenarioInfo
{
Tags = { "foo" },
Name = "",
IsFailed = false
};
var currentScenario = new ExecutionInfo
{
CurrentScenario = scenarioInfo,
CurrentSpec = specInfo
};
var currentExecutionInfo = new StepExecutionEndingRequest
{
CurrentExecutionInfo = currentScenario
};
var tags = AssertEx.ExecuteProtectedMethod <StepExecutionEndingProcessor>("GetApplicableTags", currentScenario)
.ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(1, tags.Count);
Assert.Contains("foo", tags);
}
public void OnScenarioInitialize(ScenarioInfo scenarioInfo)
{
_outputWriter = new OutputWriter();
_outputWriter.WriteFeature(_currentFeatureInfo);
_runner.OnScenarioInitialize(scenarioInfo);
_outputWriter.WriteScenario(scenarioInfo);
}
public void SendTestCaseStarted_ValidParameters_ShouldSendTestRunStartedToSink()
{
// ARRANGE
Envelope sentMessage = default;
var cucumberMessageSinkMock = new Mock <ICucumberMessageSink>();
cucumberMessageSinkMock.Setup(m => m.SendMessage(It.IsAny <Envelope>()))
.Callback <Envelope>(m => sentMessage = m);
var cucumberMessageFactoryMock = GetCucumberMessageFactoryMock();
var fieldValueProviderMock = GetFieldValueProviderMock();
var platformFactoryMock = GetPlatformFactoryMock();
var testRunResultSuccessCalculatorMock = GetTestRunResultSuccessCalculatorMock();
var sinkProviderMock = new Mock <ISinkProvider>();
sinkProviderMock.Setup(m => m.GetMessageSinksFromConfiguration()).Returns(new List <ICucumberMessageSink>()
{
cucumberMessageSinkMock.Object
});
var cucumberMessageSender = new CucumberMessageSender(cucumberMessageFactoryMock.Object, platformFactoryMock.Object, fieldValueProviderMock.Object, testRunResultSuccessCalculatorMock.Object, sinkProviderMock.Object);
var scenarioInfo = new ScenarioInfo("Test", "Description", new string[] { "Tag1" }, null);
// ACT
cucumberMessageSender.SendTestCaseStarted(scenarioInfo);
// ASSERT
sentMessage.MessageCase.Should().Be(Envelope.MessageOneofCase.TestCaseStarted);
}
public TestExecutionEngineTests()
{
specFlowConfiguration = ConfigurationLoader.GetDefault();
testThreadContainer = new ObjectContainer();
featureContainer = new ObjectContainer();
scenarioContainer = new ObjectContainer();
beforeScenarioEvents = new List <IHookBinding>();
afterScenarioEvents = new List <IHookBinding>();
beforeStepEvents = new List <IHookBinding>();
afterStepEvents = new List <IHookBinding>();
beforeFeatureEvents = new List <IHookBinding>();
afterFeatureEvents = new List <IHookBinding>();
beforeTestRunEvents = new List <IHookBinding>();
afterTestRunEvents = new List <IHookBinding>();
beforeScenarioBlockEvents = new List <IHookBinding>();
afterScenarioBlockEvents = new List <IHookBinding>();
stepDefinitionSkeletonProviderMock = new Mock <IStepDefinitionSkeletonProvider>();
testObjectResolverMock = new Mock <ITestObjectResolver>();
testObjectResolverMock.Setup(bir => bir.ResolveBindingInstance(It.IsAny <Type>(), It.IsAny <IObjectContainer>()))
.Returns((Type t, IObjectContainer container) => defaultTestObjectResolver.ResolveBindingInstance(t, container));
var culture = new CultureInfo("en-US");
contextManagerStub = new Mock <IContextManager>();
scenarioInfo = new ScenarioInfo("scenario_title", "scenario_description");
scenarioContext = new ScenarioContext(scenarioContainer, scenarioInfo, testObjectResolverMock.Object);
scenarioContainer.RegisterInstanceAs(scenarioContext);
contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext);
featureInfo = new FeatureInfo(culture, "feature_title", "", ProgrammingLanguage.CSharp);
var featureContext = new FeatureContext(featureContainer, featureInfo, specFlowConfiguration);
featureContainer.RegisterInstanceAs(featureContext);
contextManagerStub.Setup(cm => cm.FeatureContext).Returns(featureContext);
contextManagerStub.Setup(cm => cm.StepContext).Returns(new ScenarioStepContext(new StepInfo(StepDefinitionType.Given, "step_title", null, null)));
bindingRegistryStub = new Mock <IBindingRegistry>();
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeStep)).Returns(beforeStepEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterStep)).Returns(afterStepEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenarioBlock)).Returns(beforeScenarioBlockEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenarioBlock)).Returns(afterScenarioBlockEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeFeature)).Returns(beforeFeatureEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterFeature)).Returns(afterFeatureEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeTestRun)).Returns(beforeTestRunEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterTestRun)).Returns(afterTestRunEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenario)).Returns(beforeScenarioEvents);
bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenario)).Returns(afterScenarioEvents);
specFlowConfiguration = ConfigurationLoader.GetDefault();
errorProviderStub = new Mock <IErrorProvider>();
testTracerStub = new Mock <ITestTracer>();
stepDefinitionMatcherStub = new Mock <IStepDefinitionMatchService>();
methodBindingInvokerMock = new Mock <IBindingInvoker>();
stepErrorHandlers = new Dictionary <string, IStepErrorHandler>();
obsoleteTestHandlerMock = new Mock <IObsoleteStepHandler>();
}
private static bool EnableLogging(TargetOS os, TargetBrowser browser, ScenarioInfo scenario)
{
if (os == TargetOS.Windows && browser == TargetBrowser.Firefox)
{
return(false);
}
return(!scenario.Tags.Contains("DisableLogging"));
}
private static List <Label> GetTags(FeatureInfo featureInfo, ScenarioInfo scenarioInfo)
{
return(scenarioInfo.Tags
.Union(featureInfo.Tags)
.Distinct(StringComparer.CurrentCultureIgnoreCase)
.Select(x => Label.Tag(x))
.ToList());
}
public void OnScenarioStart_DefersToInnerSynchronousTestRunner()
{
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("title");
asyncTestRunner.OnScenarioStart(scenarioInfo);
testExecutionEngineStub.Verify(m => m.OnScenarioStart(scenarioInfo));
}
public void OnScenarioStart_RegistersAsyncTestRunnerInScenarioContext()
{
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("title");
asyncTestRunner.OnScenarioStart(scenarioInfo);
Assert.AreEqual(asyncTestRunner, CurrentScenarioContext.TestRunner);
}
// Fill card ScenarioCard with ScenarioINFO, located in the huis-van-morgen.json
public void FillScenarioCard(ScenarioInfo scenario)
{
this.scenario = scenario;
this.title.text = scenario.title;
this.featuredImg.sprite = Resources.Load <Sprite>(scenario.imagePath);
this.featuredImg.color = Color.white;
}
public void InitializeScenarioContext(ScenarioInfo scenarioInfo)
{
var newContext = new ScenarioContext(scenarioInfo, parentContainer);
SetupScenarioContainer(newContext);
scenarioContext.Init(newContext);
ScenarioContext.Current = newContext;
}
private void CreateElement(ScenarioInfo info)
{
ScenarioElement element = Instantiate(this.elementPrefab);
element.SetScenarioInfo(info);
element.transform.SetParent(targetTransform);
element.transform.localScale = new Vector3(1, 1, 1);
}
private void CreateScenarioRow(ScenarioInfo scenario)
{
var row = Instantiate(this.scenarioRowPrefab, this.scenarioRowContainer);
row.Clicked += OnScenarioRowClicked;
row.Construct(scenario);
this.scenarioRows.Add(row);
}
public void OnScenarioStart_RegistersAsyncExecutorInScenarioContext()
{
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("title");
asyncTestRunner.OnScenarioStart(scenarioInfo);
Assert.IsNotNull(CurrentScenarioContext.Get<IAsyncTestExecutor>());
}
public void InitializeScenarioContext(ScenarioInfo scenarioInfo)
{
var testRunner = parentContainer.Resolve <ITestRunner>(); // we need to delay-resolve the test runner to avoid circular dependencies
var newContext = new ScenarioContext(scenarioInfo, testRunner, parentContainer);
scenarioContext.Init(newContext);
ScenarioContext.Current = newContext;
}
private label[] GetScenarioLabels(FeatureInfo featureInfo, ScenarioInfo scenarioInfo)
{
var labels = scenarioInfo.Tags.Select(x => new label("feature", x)).ToList();
labels.AddRange(featureInfo.Tags.Select(x => new label("feature", x)).ToList());
labels.Add(new label("thread", Thread.CurrentThread.ManagedThreadId.ToString()));
return(labels.ToArray());
}
public void InitializeScenarioContext(ScenarioInfo scenarioInfo)
{
var scenarioContainer = containerBuilder.CreateScenarioContainer(testThreadContainer, scenarioInfo);
var newContext = scenarioContainer.Resolve <ScenarioContext>();
scenarioContextManager.Init(newContext);
ScenarioContext.Current = newContext;
}
public void OnScenarioStart_RegistersAsyncExecutorInScenarioContext()
{
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("title");
asyncTestRunner.OnScenarioStart(scenarioInfo);
Assert.IsNotNull(CurrentScenarioContext.Get <IAsyncTestExecutor>());
}
public void OnScenarioStart_RegistersAsyncTestRunnerInScenarioContext()
{
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("title");
asyncTestRunner.OnScenarioStart(scenarioInfo);
Assert.AreEqual(asyncTestRunner, CurrentScenarioContext.TestRunner);
}
private dynamic ScenarioFrom(ScenarioInfo currentScenario)
{
var executionContextScenarioType = _executionContextType.GetNestedType("Scenario");
return(currentScenario != null
? activatorWrapper.CreateInstance(executionContextScenarioType, currentScenario.Name, currentScenario.IsFailed,
currentScenario.Tags.ToArray())
: activatorWrapper.CreateInstance(executionContextScenarioType));
}
public ScenarioSession(IStatUI statUI, ScenarioInfo scenarioInfo)
{
score = 0;
hits = 0;
misses = 0;
kills = 0;
this.statUI = statUI;
this.scenarioInfo = scenarioInfo;
}
public override void SetUp()
{
base.SetUp();
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("sample scenario");
asyncTestRunner.OnScenarioStart(scenarioInfo);
}
public RunnableScenario(ScenarioInfo scenario, Func <ExtendableExecutor, object, RunnableStep[]> stepsProvider, Func <object> contextProvider, IScenarioProgressNotifier progressNotifier, ExtendableExecutor extendableExecutor)
{
_scenario = scenario;
_stepsProvider = stepsProvider;
_contextProvider = contextProvider;
_progressNotifier = progressNotifier;
_extendableExecutor = extendableExecutor;
_result = new ScenarioResult(_scenario);
}
public void SetUp()
{
mockTestRunner = MockRepository.GenerateMock<ITestRunner>();
fakeAsyncTestExecutor = new FakeAsyncTestExecutor();
asyncTestRunner = new AsyncTestRunner(mockTestRunner);
asyncTestRunner.RegisterAsyncTestExecutor(fakeAsyncTestExecutor);
var scenarioInfo = new ScenarioInfo("sample scenario");
ObjectContainer.ScenarioContext = new ScenarioContext(scenarioInfo, mockTestRunner);
asyncTestRunner.OnScenarioStart(scenarioInfo);
}
public StepContext(FeatureInfo featureInfo, ScenarioInfo scenarioInfo)
{
Language = featureInfo == null ? CultureInfoHelper.GetCultureInfo(ConfigDefaults.FeatureLanguage) : featureInfo.Language;
FeatureTitle = featureInfo == null ? null : featureInfo.Title;
ScenarioTitle = scenarioInfo == null ? null : scenarioInfo.Title;
var tags = Enumerable.Empty<string>();
if (featureInfo != null && featureInfo.Tags != null)
tags = tags.Concat(featureInfo.Tags);
if (scenarioInfo != null && scenarioInfo.Tags != null)
tags = tags.Concat(scenarioInfo.Tags).Distinct();
Tags = tags;
}
public void OnScenarioStart(ScenarioInfo scenarioInfo)
{
if (asyncTestExecutor == null)
throw new InvalidOperationException("Cannot start an asynchronous scenario with a null AsyncContext");
// No enqueueing
// The queue is logically empty at this point (we're the first thing to run in a scenario)
// and enqueueing right now will just add to an empty list
testRunner.OnScenarioStart(scenarioInfo);
// register the test executor in the scenario context to be able to used AOP style
ObjectContainer.ScenarioContext.Set(asyncTestExecutor);
ObjectContainer.ScenarioContext.SetTestRunnerUnchecked(this);
}
public void OnScenarioStart(ScenarioInfo scenarioInfo)
{
contextManager.InitializeScenarioContext(scenarioInfo);
FireScenarioEvents(BindingEvent.ScenarioStart);
}
public StepContext(FeatureInfo featureInfo, ScenarioInfo scenarioInfo)
{
FeatureInfo = featureInfo;
ScenarioInfo = scenarioInfo;
}
public void OnScenarioStart(ScenarioInfo scenarioInfo)
{
contextManager.InitializeScenarioContext(scenarioInfo);
FireScenarioEvents(HookType.BeforeScenario);
}
