public void ShouldReportArgumentMismatch()
{
const string parsedStepText = "Foo";
var request = new ExecuteStepRequest
{
ActualStepText = parsedStepText,
ParsedStepText = parsedStepText
};
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(true);
var fooMethod = new GaugeMethod {
Name = "Foo", ParameterCount = 1
};
mockStepRegistry.Setup(x => x.MethodFor(parsedStepText)).Returns(fooMethod);
var mockOrchestrator = new Mock <IExecutionOrchestrator>();
var mockTableFormatter = new Mock <ITableFormatter>();
var processor = new ExecuteStepProcessor(mockStepRegistry.Object, mockOrchestrator.Object, mockTableFormatter.Object);
var response = processor.Process(request);
Assert.True(response.ExecutionResult.Failed);
Assert.AreEqual(response.ExecutionResult.ErrorMessage,
"Argument length mismatch for Foo. Actual Count: 0, Expected Count: 1");
}
public void ShouldRegisterScreenshotWriterFromReference(string stepText, string expected)
{
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(),
new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper, activatorWrapper, new StepRegistry());
var classInstanceManager = assemblyLoader.GetClassInstanceManager();
var mockOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var executeStepProcessor = new ExecuteStepProcessor(assemblyLoader.GetStepRegistry(),
mockOrchestrator, new TableFormatter(assemblyLoader, activatorWrapper));
var message = new ExecuteStepRequest
{
ParsedStepText = stepText,
ActualStepText = stepText
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.AreEqual(protoExecutionResult.ScreenshotFiles[0], expected);
}
public void ShouldCaptureScreenshotOnFailure()
{
const string stepText = "I throw a serializable exception";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var path = new AssemblyLocater(new DirectoryWrapper()).GetTestAssembly();
var assemblyLoader = new AssemblyLoader(path, new GaugeLoadContext(path), reflectionWrapper, activatorWrapper, new StepRegistry());
var classInstanceManager = new ThreadLocal <object>(() => assemblyLoader.GetClassInstanceManager());
var executionInfoMapper = new ExecutionInfoMapper(assemblyLoader, activatorWrapper);
var orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager, executionInfoMapper),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var executeStepProcessor = new ExecuteStepProcessor(assemblyLoader.GetStepRegistry(),
orchestrator, new TableFormatter(assemblyLoader, activatorWrapper));
var message = new ExecuteStepRequest
{
ParsedStepText = stepText,
ActualStepText = stepText
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.IsTrue(protoExecutionResult.Failed);
Assert.AreEqual("screenshot.png", protoExecutionResult.FailureScreenshotFile);
}
public void ShouldProcessExecuteStepRequest()
{
const string parsedStepText = "Foo";
var request = Message.CreateBuilder()
.SetMessageType(Message.Types.MessageType.ExecuteStep)
.SetExecuteStepRequest(
ExecuteStepRequest.CreateBuilder()
.SetActualStepText(parsedStepText)
.SetParsedStepText(parsedStepText)
.AddParameters(
Parameter.CreateBuilder()
.SetParameterType(Parameter.Types.ParameterType.Static)
.SetName("Foo")
.SetValue("Bar")
.Build())
.Build())
.SetMessageId(20)
.Build();
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(true);
var fooMethodInfo = GetType().GetMethod("Foo");
mockStepRegistry.Setup(x => x.MethodFor(parsedStepText)).Returns(fooMethodInfo);
var mockMethodExecutor = new Mock <IMethodExecutor>();
mockMethodExecutor.Setup(e => e.Execute(fooMethodInfo, It.IsAny <Object[]>())).Returns(() => ProtoExecutionResult.CreateBuilder().SetExecutionTime(1).SetFailed(false).Build());
var mockSandbox = new Mock <ISandbox>();
var response = new ExecuteStepProcessor(mockStepRegistry.Object, mockMethodExecutor.Object, mockSandbox.Object).Process(request);
Assert.False(response.ExecutionStatusResponse.ExecutionResult.Failed);
}
public void ShouldReportArgumentMismatch()
{
const string parsedStepText = "Foo";
var request = Message.CreateBuilder()
.SetMessageType(Message.Types.MessageType.ExecuteStep)
.SetExecuteStepRequest(
ExecuteStepRequest.CreateBuilder()
.SetActualStepText(parsedStepText)
.SetParsedStepText(parsedStepText)
.Build())
.SetMessageId(20)
.Build();
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(true);
var fooMethodInfo = GetType().GetMethod("Foo");
mockStepRegistry.Setup(x => x.MethodFor(parsedStepText)).Returns(fooMethodInfo);
var mockMethodExecutor = new Mock <IMethodExecutor>();
var mockSandbox = new Mock <ISandbox>();
var response = new ExecuteStepProcessor(mockStepRegistry.Object, mockMethodExecutor.Object, mockSandbox.Object).Process(request);
Assert.True(response.ExecutionStatusResponse.ExecutionResult.Failed);
Assert.AreEqual(response.ExecutionStatusResponse.ExecutionResult.ErrorMessage,
"Argument length mismatch for Foo. Actual Count: 0, Expected Count: 1");
}
public void ShouldCaptureScreenshotOnFailure()
{
const string parameterizedStepText = "I throw a serializable exception";
const string stepText = "I throw a serializable exception";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(),
new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper, activatorWrapper);
var classInstanceManager = assemblyLoader.GetClassInstanceManager();
var mockOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var executeStepProcessor = new ExecuteStepProcessor(assemblyLoader.GetStepRegistry(),
mockOrchestrator, new TableFormatter(assemblyLoader, activatorWrapper));
var message = new ExecuteStepRequest
{
ParsedStepText = parameterizedStepText,
ActualStepText = stepText
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.IsTrue(protoExecutionResult.Failed);
Assert.AreEqual(protoExecutionResult.FailureScreenshotFile, "screenshot.png");
}
public void ShouldRegisterScreenshotWriterFromReference(string referenceType, string stepText, string expected)
{
Environment.SetEnvironmentVariable("GAUGE_PROJECT_ROOT", TestUtils.GetIntegrationTestSampleDirectory(referenceType));
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var path = new AssemblyLocater(new DirectoryWrapper()).GetTestAssembly();
var assemblyLoader = new AssemblyLoader(path, new GaugeLoadContext(path), reflectionWrapper, activatorWrapper, new StepRegistry());
var classInstanceManager = new ThreadLocal <object>(() => assemblyLoader.GetClassInstanceManager()).Value;
var executionInfoMapper = new ExecutionInfoMapper(assemblyLoader, activatorWrapper);
var executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager, executionInfoMapper),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var executeStepProcessor = new ExecuteStepProcessor(assemblyLoader.GetStepRegistry(),
executionOrchestrator, new TableFormatter(assemblyLoader, activatorWrapper));
var message = new ExecuteStepRequest
{
ParsedStepText = stepText,
ActualStepText = stepText
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Console.WriteLine(protoExecutionResult.ScreenshotFiles[0]);
Assert.AreEqual(protoExecutionResult.ScreenshotFiles[0], expected);
}
public void ShouldExecuteMethodFromRequest()
{
const string parameterizedStepText = "Step that takes a table {}";
const string stepText = "Step that takes a table <table>";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var path = new AssemblyLocater(new DirectoryWrapper()).GetTestAssembly();
var assemblyLoader = new AssemblyLoader(path, new GaugeLoadContext(path), reflectionWrapper, activatorWrapper, new StepRegistry());
var executionInfoMapper = new ExecutionInfoMapper(assemblyLoader, activatorWrapper);
var classInstanceManager = assemblyLoader.GetClassInstanceManager();
var orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager, executionInfoMapper),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var executeStepProcessor = new ExecuteStepProcessor(assemblyLoader.GetStepRegistry(),
orchestrator, new TableFormatter(assemblyLoader, activatorWrapper));
var protoTable = new ProtoTable
{
Headers = new ProtoTableRow
{
Cells = { "foo", "bar" }
},
Rows =
{
new ProtoTableRow
{
Cells ={ "foorow1", "foorow2" }
}
}
};
var message = new ExecuteStepRequest
{
ParsedStepText = parameterizedStepText,
ActualStepText = stepText,
Parameters =
{
new Parameter
{
Name = "table",
ParameterType = Parameter.Types.ParameterType.Table,
Table = protoTable
}
}
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.IsFalse(protoExecutionResult.Failed);
}
public void ShouldProcessExecuteStepRequestForTableParam(Parameter.Types.ParameterType parameterType)
{
const string parsedStepText = "Foo";
var protoTable = new ProtoTable();
var tableJSON = "{'headers':['foo', 'bar'],'rows':[['foorow1','barrow1']]}";
var request = new ExecuteStepRequest
{
ActualStepText = parsedStepText,
ParsedStepText = parsedStepText,
Parameters =
{
new Parameter
{
ParameterType = parameterType,
Table = protoTable
}
}
};
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(true);
var fooMethodInfo = new GaugeMethod {
Name = "Foo", ParameterCount = 1
};
mockStepRegistry.Setup(x => x.MethodFor(parsedStepText)).Returns(fooMethodInfo);
var mockOrchestrator = new Mock <IExecutionOrchestrator>();
mockOrchestrator.Setup(e => e.ExecuteStep(fooMethodInfo, It.IsAny <string[]>())).Returns(() =>
new ProtoExecutionResult
{
ExecutionTime = 1,
Failed = false
});
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector));
var mockTableFormatter = new Mock <ITableFormatter>();
mockTableFormatter.Setup(x => x.GetJSON(protoTable))
.Returns(tableJSON);
var processor = new ExecuteStepProcessor(mockStepRegistry.Object, mockOrchestrator.Object, mockTableFormatter.Object);
var response = processor.Process(request);
mockOrchestrator.Verify(executor =>
executor.ExecuteStep(fooMethodInfo, It.Is <string[]>(strings => strings[0] == tableJSON)));
Assert.False(response.ExecutionResult.Failed);
}
public void ShouldReportMissingStep()
{
const string parsedStepText = "Foo";
var request = new ExecuteStepRequest
{
ActualStepText = parsedStepText,
ParsedStepText = parsedStepText
};
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(false);
var mockOrchestrator = new Mock <IExecutionOrchestrator>();
var mockTableFormatter = new Mock <ITableFormatter>();
var processor = new ExecuteStepProcessor(mockStepRegistry.Object, mockOrchestrator.Object, mockTableFormatter.Object);
var response = processor.Process(request);
Assert.True(response.ExecutionResult.Failed);
Assert.AreEqual(response.ExecutionResult.ErrorMessage,
"Step Implementation not found");
}
public void ShouldProcessExecuteStepRequest()
{
const string parsedStepText = "Foo";
var request = new ExecuteStepRequest
{
ActualStepText = parsedStepText,
ParsedStepText = parsedStepText,
Parameters =
{
new Parameter
{
ParameterType = Parameter.Types.ParameterType.Static,
Name = "Foo",
Value = "Bar"
}
}
};
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(true);
var fooMethodInfo = new GaugeMethod {
Name = "Foo", ParameterCount = 1
};
mockStepRegistry.Setup(x => x.MethodFor(parsedStepText)).Returns(fooMethodInfo);
var mockOrchestrator = new Mock <IExecutionOrchestrator>();
mockOrchestrator.Setup(e => e.ExecuteStep(fooMethodInfo, It.IsAny <string[]>()))
.Returns(() => new ProtoExecutionResult {
ExecutionTime = 1, Failed = false
});
var mockTableFormatter = new Mock <ITableFormatter>();
var processor = new ExecuteStepProcessor(mockStepRegistry.Object, mockOrchestrator.Object, mockTableFormatter.Object);
var response = processor.Process(request);
Assert.False(response.ExecutionResult.Failed);
}
public void ShouldReportMissingStep()
{
const string parsedStepText = "Foo";
var request = Message.CreateBuilder()
.SetMessageType(Message.Types.MessageType.ExecuteStep)
.SetExecuteStepRequest(
ExecuteStepRequest.CreateBuilder()
.SetActualStepText(parsedStepText)
.SetParsedStepText(parsedStepText)
.Build())
.SetMessageId(20)
.Build();
var mockStepRegistry = new Mock <IStepRegistry>();
mockStepRegistry.Setup(x => x.ContainsStep(parsedStepText)).Returns(false);
var mockMethodExecutor = new Mock <IMethodExecutor>();
var response = new ExecuteStepProcessor(mockStepRegistry.Object, mockMethodExecutor.Object).Process(request);
Assert.True(response.ExecutionStatusResponse.ExecutionResult.Failed);
Assert.AreEqual(response.ExecutionStatusResponse.ExecutionResult.ErrorMessage,
"Step Implementation not found");
}
public ExecutionStatusResponse Process(ExecuteStepRequest request)
{
if (!_stepRegistry.ContainsStep(request.ParsedStepText))
{
return(ExecutionError("Step Implementation not found"));
}
var method = _stepRegistry.MethodFor(request.ParsedStepText);
var parameters = method.ParameterCount;
var args = new string[parameters];
var stepParameter = request.Parameters;
if (parameters != stepParameter.Count)
{
var argumentMismatchError = string.Format(
"Argument length mismatch for {0}. Actual Count: {1}, Expected Count: {2}",
request.ActualStepText,
stepParameter.Count, parameters);
return(ExecutionError(argumentMismatchError));
}
var validTableParamTypes = new[]
{ Parameter.Types.ParameterType.Table, Parameter.Types.ParameterType.SpecialTable };
for (var i = 0; i < parameters; i++)
{
args[i] = validTableParamTypes.Contains(stepParameter[i].ParameterType)
? _tableFormatter.GetJSON(stepParameter[i].Table)
: stepParameter[i].Value;
}
var protoExecutionResult = _executionOrchestrator.ExecuteStep(method, args);
return(new ExecutionStatusResponse {
ExecutionResult = protoExecutionResult
});
}
public override Task <ExecutionStatusResponse> ExecuteStep(ExecuteStepRequest request, ServerCallContext context)
{
return(_pool.Execute(getStream(request.Stream), () => this.executeStepProcessor.Process(request)));
}
public override Task <ExecutionStatusResponse> ExecuteStep(ExecuteStepRequest request, ServerCallContext context)
{
return(Task.FromResult(this.executeStepProcessor.Process(request)));
}
