public void ShouldGetTagListFromExecutionInfo()
{
var specInfo = new SpecInfo
{
Tags = { "foo" },
Name = "",
FileName = "",
IsFailed = false
};
var scenarioInfo = new ScenarioInfo
{
Tags = { "bar" },
Name = "",
IsFailed = false
};
var currentScenario = new ExecutionInfo
{
CurrentSpec = specInfo,
CurrentScenario = scenarioInfo
};
var currentExecutionInfo = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = currentScenario
};
var tags = AssertEx.ExecuteProtectedMethod <ScenarioExecutionStartingProcessor>("GetApplicableTags", currentScenario)
.ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(2, tags.Count);
Assert.Contains("foo", tags);
Assert.Contains("bar", tags);
}
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 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 void ShouldNotFetchDuplicateTags()
{
var specInfo = SpecInfo.CreateBuilder()
.AddTags("foo")
.SetName("")
.SetFileName("")
.SetIsFailed(false)
.Build();
var scenarioInfo = ScenarioInfo.CreateBuilder()
.AddTags("foo")
.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 <ScenarioExecutionStartingProcessor>("GetApplicableTags", message).ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(1, tags.Count);
Assert.Contains("foo", tags);
}
public void ShouldExecutreBeforeScenarioHook()
{
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotCollector)).Returns(mockType);
var scenarioExecutionStartingRequest = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = new ExecutionInfo
{
CurrentSpec = new SpecInfo(),
CurrentScenario = new ScenarioInfo()
}
};
var request = new Message
{
MessageId = 20,
MessageType = Message.Types.MessageType.SpecExecutionStarting,
ScenarioExecutionStartingRequest = scenarioExecutionStartingRequest
};
var mockMethodExecutor = new Mock <IExecutionOrchestrator>();
var protoExecutionResult = new ProtoExecutionResult
{
ExecutionTime = 0,
Failed = false
};
IEnumerable <string> pendingMessages = new List <string> {
"one", "two"
};
mockMethodExecutor.Setup(x =>
x.ExecuteHooks("BeforeScenario", It.IsAny <HooksStrategy>(), It.IsAny <IList <string> >(),
It.IsAny <ExecutionContext>()))
.Returns(protoExecutionResult);
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
var pendingScreenshot = new List <byte[]> {
Encoding.ASCII.GetBytes("Screenshot")
};
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshots", It.IsAny <BindingFlags>()))
.Returns(pendingScreenshot);
var processor = new ScenarioExecutionStartingProcessor(mockMethodExecutor.Object,
mockAssemblyLoader.Object, mockReflectionWrapper.Object);
var result = processor.Process(request);
Assert.False(result.ExecutionStatusResponse.ExecutionResult.Failed);
Assert.AreEqual(result.ExecutionStatusResponse.ExecutionResult.Message.ToList(), pendingMessages);
Assert.AreEqual(result.ExecutionStatusResponse.ExecutionResult.ScreenShot.ToList(), pendingScreenshot);
}
public void ShouldExecutreBeforeScenarioHook()
{
var scenarioExecutionEndingRequest = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = new ExecutionInfo
{
CurrentSpec = new SpecInfo(),
CurrentScenario = new ScenarioInfo()
}
};
var request = new Message
{
MessageId = 20,
MessageType = Message.Types.MessageType.SpecExecutionStarting,
ScenarioExecutionStartingRequest = scenarioExecutionEndingRequest
};
var mockMethodExecutor = new Mock <IExecutionOrchestrator>();
var protoExecutionResult = new ProtoExecutionResult
{
ExecutionTime = 0,
Failed = false
};
var pendingMessages = new List <string> {
"one", "two"
};
var pendingScreenshots = new List <byte[]> {
Encoding.ASCII.GetBytes("screenshot")
};
mockMethodExecutor.Setup(x =>
x.ExecuteHooks("BeforeScenario", It.IsAny <HooksStrategy>(), It.IsAny <IList <string> >(),
It.IsAny <ExecutionContext>()))
.Returns(protoExecutionResult);
mockMethodExecutor.Setup(x =>
x.GetAllPendingMessages()).Returns(pendingMessages);
mockMethodExecutor.Setup(x =>
x.GetAllPendingScreenshots()).Returns(pendingScreenshots);
var processor = new ScenarioExecutionStartingProcessor(mockMethodExecutor.Object);
var result = processor.Process(request);
Assert.False(result.ExecutionStatusResponse.ExecutionResult.Failed);
Assert.AreEqual(result.ExecutionStatusResponse.ExecutionResult.Message.ToList(), pendingMessages);
Assert.AreEqual(result.ExecutionStatusResponse.ExecutionResult.Screenshots.ToList(), pendingScreenshots);
}
public override Task <Empty> NotifyScenarioExecutionStarting(ScenarioExecutionStartingRequest request, ServerCallContext context)
{
try
{
TraceLogger.Info($"{nameof(NotifyScenarioExecutionStarting)} received");
TraceLogger.Verbose(System.Text.Json.JsonSerializer.Serialize(request));
if (request.ScenarioResult != null)
{
_sender.StartScenario(request);
}
}
catch (Exception exp)
{
TraceLogger.Error(exp.ToString());
}
return(Task.FromResult(new Empty()));
}
public void ShouldExecuteBeforeScenarioHook()
{
var scenarioExecutionEndingRequest = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = new ExecutionInfo
{
CurrentSpec = new SpecInfo(),
CurrentScenario = new ScenarioInfo()
}
};
var mockMethodExecutor = new Mock <IExecutionOrchestrator>();
var protoExecutionResult = new ProtoExecutionResult
{
ExecutionTime = 0,
Failed = false
};
var pendingMessages = new List <string> {
"one", "two"
};
var pendingScreenshotFiles = new List <string> {
"screenshot.png"
};
mockMethodExecutor.Setup(x =>
x.ExecuteHooks("BeforeScenario", It.IsAny <HooksStrategy>(), It.IsAny <IList <string> >(),
It.IsAny <ExecutionInfo>()))
.Returns(protoExecutionResult);
mockMethodExecutor.Setup(x =>
x.GetAllPendingMessages()).Returns(pendingMessages);
mockMethodExecutor.Setup(x =>
x.GetAllPendingScreenshotFiles()).Returns(pendingScreenshotFiles);
var processor = new ScenarioExecutionStartingProcessor(mockMethodExecutor.Object);
var result = processor.Process(scenarioExecutionEndingRequest);
Assert.False(result.ExecutionResult.Failed);
Assert.AreEqual(result.ExecutionResult.Message.ToList(), pendingMessages);
Assert.AreEqual(result.ExecutionResult.ScreenshotFiles.ToList(), pendingScreenshotFiles);
}
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 currentExecutionInfo = new ScenarioExecutionStartingRequest
{
CurrentExecutionInfo = currentScenario
};
var message = new Message
{
ScenarioExecutionStartingRequest = currentExecutionInfo,
MessageType = Message.Types.MessageType.ScenarioExecutionStarting,
MessageId = 0
};
var tags = AssertEx.ExecuteProtectedMethod <ScenarioExecutionStartingProcessor>("GetApplicableTags", message)
.ToList();
Assert.IsNotEmpty(tags);
Assert.AreEqual(1, tags.Count);
Assert.Contains("foo", tags);
}
public void StartScenario(ScenarioExecutionStartingRequest request)
{
var scenarioResult = request.ScenarioResult.ProtoItem;
ProtoScenario scenario;
switch (scenarioResult.ItemType)
{
case ProtoItem.Types.ItemType.Scenario:
scenario = scenarioResult.Scenario;
break;
case ProtoItem.Types.ItemType.TableDrivenScenario:
scenario = scenarioResult.TableDrivenScenario.Scenario;
break;
default:
scenario = scenarioResult.Scenario;
break;
}
var specReporter = _specs[GetSpecKey(request.CurrentExecutionInfo, request.CurrentExecutionInfo.CurrentSpec)];
// find TestCaseId
var testCaseIdTagPrefix = "TestCaseId:";
string testCaseIdTagValue = null;
var testCaseIdTag = scenario.Tags.FirstOrDefault(t => t.ToLowerInvariant().StartsWith(testCaseIdTagPrefix.ToLowerInvariant()));
if (testCaseIdTag != null)
{
testCaseIdTagValue = testCaseIdTag.Substring(testCaseIdTagPrefix.Length);
}
// parse scenario parameters
var scenarioRequestParameters = new List <KeyValuePair <string, string> >();
var scenarioStepFragments = scenarioResult.Scenario.ScenarioItems?
.Where(si => si.ItemType == ProtoItem.Types.ItemType.Step && si.Step != null && si.Step.Fragments != null)
.SelectMany(si => si.Step.Fragments.Where(f => f.FragmentType == Fragment.Types.FragmentType.Parameter));
foreach (var scenarioStepFragment in scenarioStepFragments)
{
var paramName = scenarioStepFragment.Parameter.Name;
var paramValue = scenarioStepFragment.Parameter.Value;
scenarioRequestParameters.Add(new KeyValuePair <string, string>(paramName, paramValue));
}
var attributes = scenario.Tags.Select(t => new ItemAttributeConverter().ConvertFrom(t, opts => opts.UndefinedKey = "tag")).ToList();
// inherit scenario tags from specification
attributes.AddRange(request.CurrentExecutionInfo.CurrentSpec.Tags.Select(t => new ItemAttributeConverter().ConvertFrom(t, opts => opts.UndefinedKey = "tag")).ToList());
var startTestItemRequest = new StartTestItemRequest
{
Type = TestItemType.Step,
StartTime = DateTime.UtcNow,
Name = scenario.ScenarioHeading,
Description = string.Join("", scenario.ScenarioItems.Where(i => i.ItemType == ProtoItem.Types.ItemType.Comment).Select(c => c.Comment.Text)),
Attributes = attributes,
TestCaseId = testCaseIdTagValue,
Parameters = scenarioRequestParameters
};
// parse scenario retry
if (request.CurrentExecutionInfo?.ExecutionArgs?.Any(arg => arg.FlagName.Equals("max-retries-count", StringComparison.InvariantCultureIgnoreCase)) == true)
{
startTestItemRequest.IsRetry = true;
}
var scenarioReporter = specReporter.StartChildTestReporter(startTestItemRequest);
// pre hook messages
if (scenarioResult.Scenario.PreHookMessages.Count != 0 || scenarioResult.Scenario.PreHookFailure != null)
{
foreach (var preHookMessage in scenarioResult.Scenario.PreHookMessages)
{
scenarioReporter.Log(new CreateLogItemRequest
{
Level = LogLevel.Debug,
Text = preHookMessage,
Time = DateTime.UtcNow
});
}
if (scenarioResult.Scenario.PreHookFailure != null)
{
var preHookFailure = scenarioResult.Scenario.PreHookFailure;
scenarioReporter.Log(new CreateLogItemRequest
{
Level = LogLevel.Error,
Text = $"{preHookFailure.ErrorMessage}{Environment.NewLine}{preHookFailure.StackTrace}",
Time = DateTime.UtcNow
});
}
}
var key = GetScenarioKey(request.CurrentExecutionInfo, request.CurrentExecutionInfo.CurrentSpec, request.CurrentExecutionInfo.CurrentScenario);
_scenarios[key] = scenarioReporter;
}
public override Task <ExecutionStatusResponse> StartScenarioExecution(ScenarioExecutionStartingRequest request, ServerCallContext context)
{
return(_pool.Execute(getStream(request.Stream), () => this.scenarioExecutionStartingProcessor.Process(request)));
}
public override Task <ExecutionStatusResponse> StartScenarioExecution(ScenarioExecutionStartingRequest request, ServerCallContext context)
{
return(Task.FromResult(this.scenarioExecutionStartingProcessor.Process(request)));
}
public override Task <Empty> NotifyScenarioExecutionStarting(ScenarioExecutionStartingRequest request, ServerCallContext context)
{
return(Task.FromResult(new Empty()));
}
public ExecutionStatusResponse Process(ScenarioExecutionStartingRequest request)
{
_executionOrchestrator.StartExecutionScope("scenario");
return(ExecuteHooks(request.CurrentExecutionInfo));
}
