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 ShouldExecuteHooks()
{
var executionResult = new ExecutionResult {
Success = true
};
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockClassInstanceManager = new Mock <object>().Object;
var hooksStrategy = new HooksStrategy();
var mockHookExecuter = new Mock <IHookExecutor>();
mockHookExecuter.Setup(m =>
m.Execute("hooks", hooksStrategy, new List <string>(), It.IsAny <ExecutionContext>())
).Returns(executionResult).Verifiable();
var mockStepExecuter = new Mock <IStepExecutor>();
var reflectionWrapper = mockReflectionWrapper.Object;
var assemblyLoader = mockAssemblyLoader.Object;
var executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, mockActivationWrapper.Object,
mockClassInstanceManager, mockHookExecuter.Object, mockStepExecuter.Object);
var result = executionOrchestrator.ExecuteHooks("hooks", hooksStrategy, new List <string>(),
It.IsAny <ExecutionContext>());
mockHookExecuter.VerifyAll();
Assert.False(result.Failed);
}
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 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 ShouldCreateTableFromTargetType()
{
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 orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("Step that takes a table {}");
var table = new Table(new List <string> {
"foo", "bar"
});
table.AddRow(new List <string> {
"foorow1", "barrow1"
});
table.AddRow(new List <string> {
"foorow2", "barrow2"
});
var executionResult = orchestrator.ExecuteStep(gaugeMethod, SerializeTable(table));
Assert.False(executionResult.Failed);
}
public void ShouldExecuteMethod()
{
var gaugeMethod = new GaugeMethod {
Name = "ShouldExecuteMethod", ParameterCount = 1
};
var args = new[] { "Bar", "String" };
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(() => new ExecutionResult {
Success = true
})
.Callback(() => Thread.Sleep(1)); // Simulate a delay in method execution
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecutor.Object);
var result = orchestrator.ExecuteStep(gaugeMethod, args);
mockStepExecutor.VerifyAll();
Assert.False(result.Failed);
Assert.True(result.ExecutionTime > 0);
}
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 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 assemblyLoader = new AssemblyLoader(new AssemblyWrapper(),
new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var classInstanceManager = assemblyLoader.GetClassInstanceManager(activatorWrapper);
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 protoTable = new ProtoTable
{
Headers = new ProtoTableRow
{
Cells = { "foo", "bar" }
},
Rows =
{
new ProtoTableRow
{
Cells ={ "foorow1", "foorow2" }
}
}
};
var message = new Message
{
MessageId = 1234,
MessageType = Message.Types.MessageType.ExecuteStep,
ExecuteStepRequest = new ExecuteStepRequest
{
ParsedStepText = parameterizedStepText,
ActualStepText = stepText,
Parameters =
{
new Parameter
{
Name = "table",
ParameterType = Parameter.Types.ParameterType.Table,
Table = protoTable
}
}
}
};
var result = executeStepProcessor.Process(message);
AssertRunnerDomainDidNotLoadUsersAssembly();
var protoExecutionResult = result.ExecutionStatusResponse.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.IsFalse(protoExecutionResult.Failed);
}
public void ShouldExecuteHooksAndNotTakeScreenshotOnFailureWhenDisabled()
{
var pendingMessages = new List <string> {
"Foo", "Bar"
};
var pendingScrennshots = new List <byte[]> {
Encoding.ASCII.GetBytes("screenshot")
};
var hooksStrategy = new HooksStrategy();
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "Some Error",
StackTrace = "StackTrace"
};
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecuter = new Mock <IStepExecutor>();
var reflectionWrapper = mockReflectionWrapper.Object;
var assemblyLoader = mockAssemblyLoader.Object;
var orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
mockActivationWrapper.Object,
mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecuter.Object);
mockHookExecuter.Setup(executor =>
executor.Execute("hooks", hooksStrategy, new List <string>(), It.IsAny <ExecutionContext>())
).Returns(executionResult).Verifiable();
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotCollector)).Returns(mockType);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshots", It.IsAny <BindingFlags>()))
.Returns(pendingScrennshots);
var screenshotEnabled = Utils.TryReadEnvValue("SCREENSHOT_ON_FAILURE");
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", "false");
var result = orchestrator.ExecuteHooks("hooks", hooksStrategy, new List <string>(),
new ExecutionContext());
mockHookExecuter.VerifyAll();
Assert.True(result.Failed);
Assert.True(result.FailureScreenshot.IsNullOrEmpty());
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", screenshotEnabled);
}
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 ShouldNotTakeScreenShotWhenDisabled()
{
var pendingMessages = new List <string> {
"Foo", "Bar"
};
var pendingScreenshots = new List <string> {
"screenshot.png"
};
var gaugeMethod = new GaugeMethod {
Name = "ShouldNotTakeScreenShotWhenDisabled", ParameterCount = 1
};
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "Some Error",
StackTrace = "StackTrace"
};
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(executionResult);
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotFilesCollector)).Returns(mockType);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshotFiles", It.IsAny <BindingFlags>()))
.Returns(pendingScreenshots);
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecutor.Object);
var screenshotEnabled = Utils.TryReadEnvValue("SCREENSHOT_ON_FAILURE");
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", "false");
var result = orchestrator.ExecuteStep(gaugeMethod, "Bar", "string");
mockStepExecutor.VerifyAll();
Assert.True(result.FailureScreenshotFile.IsNullOrEmpty());
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", screenshotEnabled);
}
public void ShouldTakeScreenShotOnFailedExecution()
{
var pendingMessages = new List <string> {
"Foo", "Bar"
};
var expectedScreenshot = "Testscreenshot.png";
var pendingScreenshots = new List <string> {
expectedScreenshot
};
var gaugeMethod = new GaugeMethod {
Name = "ShouldExecuteMethod", ParameterCount = 1
};
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "error",
StackTrace = "stacktrace"
};
var mockInstance = new Mock <object>().Object;
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(executionResult).Verifiable();
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotFilesCollector)).Returns(mockType);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshotFiles", It.IsAny <BindingFlags>()))
.Returns(pendingScreenshots);
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockInstance,
mockHookExecuter.Object, mockStepExecutor.Object);
var result = orchestrator.ExecuteStep(gaugeMethod, "Bar", "String");
mockStepExecutor.VerifyAll();
Assert.True(result.Failed);
Assert.AreEqual(expectedScreenshot, result.FailureScreenshotFile);
}
public void ShouldExecuteMethod()
{
var pendingMessages = new List <string> {
"Foo", "Bar"
};
var pendingScrennshots = new List <byte[]> {
Encoding.ASCII.GetBytes("screenshot")
};
var gaugeMethod = new GaugeMethod {
Name = "ShouldExecuteMethod", ParameterCount = 1
};
var args = new[] { "Bar", "String" };
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(() => new ExecutionResult {
Success = true
})
.Callback(() => Thread.Sleep(1)); // Simulate a delay in method execution
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecutor.Object);
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotCollector)).Returns(mockType);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshots", It.IsAny <BindingFlags>()))
.Returns(pendingScrennshots);
var result = orchestrator.ExecuteStep(gaugeMethod, args);
mockStepExecutor.VerifyAll();
Assert.False(result.Failed);
Assert.True(result.ExecutionTime > 0);
}
public void ShouldTakeScreenShotOnFailedExecution()
{
var gaugeMethod = new GaugeMethod {
Name = "ShouldExecuteMethod", ParameterCount = 1
};
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "error",
StackTrace = "stacktrace"
};
var expectedScreenshot = Encoding.UTF8.GetBytes("TestScreenshot");
var type = new Mock <Type>().Object;
var mockInstance = new Mock <object>().Object;
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
mockAssemblyLoader.Setup(x => x.ScreengrabberType).Returns(type);
var mockActivationWrapper = new Mock <IActivatorWrapper>();
mockActivationWrapper.Setup(x => x.CreateInstance(type)).Returns(mockInstance);
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
mockReflectionWrapper
.Setup(x => x.InvokeMethod(type, mockInstance, "TakeScreenShot"))
.Returns(expectedScreenshot);
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(executionResult).Verifiable();
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockInstance,
mockHookExecuter.Object, mockStepExecutor.Object);
var result = orchestrator.ExecuteStep(gaugeMethod, "Bar", "String");
mockStepExecutor.VerifyAll();
Assert.True(result.Failed);
Assert.AreEqual(expectedScreenshot, result.ScreenShot);
}
public void ShouldExecuteMethodAndReturnResult()
{
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 orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry()
.MethodFor("A context step which gets executed before every scenario");
var executionResult = orchestrator.ExecuteStep(gaugeMethod);
Assert.False(executionResult.Failed);
}
public void RecoverableIsTrueOnExceptionThrownWhenContinueOnFailure()
{
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 orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry()
.MethodFor("I throw a serializable exception and continue");
var executionResult = orchestrator.ExecuteStep(gaugeMethod);
Assert.IsTrue(executionResult.Failed);
Assert.IsTrue(executionResult.RecoverableError);
}
public void ShouldExecuteHooks()
{
var pendingMessages = new List <string> {
"Foo", "Bar"
};
var pendingScrennshots = new List <byte[]> {
Encoding.ASCII.GetBytes("screenshot")
};
var executionResult = new ExecutionResult {
Success = true
};
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockClassInstanceManager = new Mock <object>().Object;
var hooksStrategy = new HooksStrategy();
var mockHookExecuter = new Mock <IHookExecutor>();
mockHookExecuter.Setup(m =>
m.Execute("hooks", hooksStrategy, new List <string>(), It.IsAny <ExecutionContext>())
).Returns(executionResult).Verifiable();
var mockStepExecuter = new Mock <IStepExecutor>();
var reflectionWrapper = mockReflectionWrapper.Object;
var mockType = new Mock <Type>().Object;
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)).Returns(mockType);
mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotCollector)).Returns(mockType);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingMessages", It.IsAny <BindingFlags>()))
.Returns(pendingMessages);
mockReflectionWrapper.Setup(x =>
x.InvokeMethod(mockType, null, "GetAllPendingScreenshots", It.IsAny <BindingFlags>()))
.Returns(pendingScrennshots);
var assemblyLoader = mockAssemblyLoader.Object;
var executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
mockActivationWrapper.Object,
mockClassInstanceManager, mockHookExecuter.Object, mockStepExecuter.Object);
var result = executionOrchestrator.ExecuteHooks("hooks", hooksStrategy, new List <string>(),
It.IsAny <ExecutionContext>());
mockHookExecuter.VerifyAll();
Assert.False(result.Failed);
}
public void ShouldGetPendingMessages()
{
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 executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("Say {} to {}");
var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod, "hello", "world");
Assert.False(executionResult.Failed);
Assert.Contains("hello, world!", executionResult.Message);
}
public void ShouldGetStacktraceForAggregateException()
{
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 executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("I throw an AggregateException");
var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod);
Assert.True(executionResult.Failed);
Assert.True(executionResult.StackTrace.Contains("First Exception"));
Assert.True(executionResult.StackTrace.Contains("Second Exception"));
}
public void SuccessIsFalseOnUnserializableExceptionThrown()
{
const string expectedMessage = "I am a custom exception";
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 executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader, activatorWrapper,
classInstanceManager,
new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager),
new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("I throw an unserializable exception");
var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod);
Assert.True(executionResult.Failed);
Assert.AreEqual(expectedMessage, executionResult.ErrorMessage);
StringAssert.Contains("IntegrationTestSample.StepImplementation.ThrowUnserializableException",
executionResult.StackTrace);
}
public void ShouldExecuteHooksAndNotTakeScreenshotOnFailureWhenDisabled()
{
var hooksStrategy = new HooksStrategy();
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "Some Error",
StackTrace = "StackTrace"
};
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecuter = new Mock <IStepExecutor>();
var reflectionWrapper = mockReflectionWrapper.Object;
var assemblyLoader = mockAssemblyLoader.Object;
var orchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
mockActivationWrapper.Object,
mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecuter.Object);
mockHookExecuter.Setup(executor =>
executor.Execute("hooks", hooksStrategy, new List <string>(), It.IsAny <ExecutionContext>())
).Returns(executionResult).Verifiable();
var screenshotEnabled = Utils.TryReadEnvValue("SCREENSHOT_ON_FAILURE");
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", "false");
var result = orchestrator.ExecuteHooks("hooks", hooksStrategy, new List <string>(),
new ExecutionContext());
mockHookExecuter.VerifyAll();
Assert.True(result.Failed);
Assert.True(result.ScreenShot.IsNullOrEmpty());
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", screenshotEnabled);
}
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);
var classInstanceManager = assemblyLoader.GetClassInstanceManager(activatorWrapper);
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 Message
{
MessageType = Message.Types.MessageType.ExecuteStep,
ExecuteStepRequest = new ExecuteStepRequest
{
ParsedStepText = parameterizedStepText,
ActualStepText = stepText
}
};
var result = executeStepProcessor.Process(message);
var protoExecutionResult = result.ExecutionStatusResponse.ExecutionResult;
Assert.IsNotNull(protoExecutionResult);
Assert.IsTrue(protoExecutionResult.Failed);
Assert.AreEqual(protoExecutionResult.ScreenShot.Count, 1);
Assert.AreEqual(Encoding.UTF8.GetString(protoExecutionResult.ScreenShot[0].ToByteArray()), "ScreenShot");
}
public void ShouldNotTakeScreenShotWhenDisabled()
{
var gaugeMethod = new GaugeMethod {
Name = "ShouldNotTakeScreenShotWhenDisabled", ParameterCount = 1
};
var executionResult = new ExecutionResult
{
Success = false,
ExceptionMessage = "Some Error",
StackTrace = "StackTrace"
};
var mockClassInstanceManager = new Mock <object>().Object;
var mockReflectionWrapper = new Mock <IReflectionWrapper>();
var mockAssemblyLoader = new Mock <IAssemblyLoader>();
var mockActivationWrapper = new Mock <IActivatorWrapper>();
var mockHookExecuter = new Mock <IHookExecutor>();
var mockStepExecutor = new Mock <IStepExecutor>();
mockStepExecutor.Setup(executor => executor.Execute(gaugeMethod, It.IsAny <string[]>()))
.Returns(executionResult);
var orchestrator = new ExecutionOrchestrator(mockReflectionWrapper.Object, mockAssemblyLoader.Object,
mockActivationWrapper.Object, mockClassInstanceManager,
mockHookExecuter.Object, mockStepExecutor.Object);
var screenshotEnabled = Utils.TryReadEnvValue("SCREENSHOT_ON_FAILURE");
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", "false");
var result = orchestrator.ExecuteStep(gaugeMethod, "Bar", "string");
mockStepExecutor.VerifyAll();
Assert.True(result.ScreenShot.IsNullOrEmpty());
Environment.SetEnvironmentVariable("SCREENSHOT_ON_FAILURE", screenshotEnabled);
}
