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))); }