public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.BeforeSuiteHooks).Returns(hooks); _mockMethodExecutor = new Mock <IExecutionOrchestrator>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false }; _mockMethodExecutor.Setup(x => x.ExecuteHooks("BeforeSuite", It.IsAny <HooksStrategy>(), It.IsAny <IList <string> >(), It.IsAny <ExecutionContext>())) .Returns(_protoExecutionResult); _mockMethodExecutor.Setup(x => x.GetAllPendingMessages()).Returns(_pendingMessages); _mockMethodExecutor.Setup(x => x.GetAllPendingScreenshotFiles()).Returns(_pendingScreenshotFiles); _executionStartingProcessor = new ExecutionStartingProcessor(_mockMethodExecutor.Object); }
public void Setup() { var mockAssemblyLoader = new Mock <IAssemblyLoader>(); mockFooMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("FooMethod") .WithFilteredHook(LibType.BeforeScenario, "Foo") .Build(); mockBarMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("BarMethod") .WithFilteredHook(LibType.BeforeScenario, "Bar", "Baz") .Build(); mockBazMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("BazMethod") .WithFilteredHook(LibType.BeforeScenario, "Foo", "Baz") .WithTagAggregation(1) .Build(); mockBlahMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("BlahMethod") .WithFilteredHook(LibType.BeforeScenario) .Build(); _hookMethods = new List <IHookMethod> { new HookMethod(LibType.BeforeScenario, mockFooMethod, mockAssemblyLoader.Object), new HookMethod(LibType.BeforeScenario, mockBarMethod, mockAssemblyLoader.Object), new HookMethod(LibType.BeforeScenario, mockBazMethod, mockAssemblyLoader.Object), new HookMethod(LibType.BeforeScenario, mockBlahMethod, mockAssemblyLoader.Object) }; }
public void ShouldNotBeRecoverable() { var assemblyLoader = new Mock <IAssemblyLoader>(); var fooMethod = new MockMethodBuilder(assemblyLoader) .WithName("Foo") .WithStep("Foo") .Build(); Assert.False(fooMethod.IsRecoverableStep(assemblyLoader.Object)); }
public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); 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 mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.AfterSuiteHooks).Returns(hooks); var executionEndingRequest = new ExecutionEndingRequest { CurrentExecutionInfo = new ExecutionInfo { CurrentSpec = new SpecInfo(), CurrentScenario = new ScenarioInfo() } }; _request = new Message { MessageId = 20, MessageType = Message.Types.MessageType.ExecutionEnding, ExecutionEndingRequest = executionEndingRequest }; _mockMethodExecutor = new Mock <IExecutionOrchestrator>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false }; _mockMethodExecutor.Setup(x => x.ExecuteHooks("AfterSuite", 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); mockReflectionWrapper.Setup(x => x.InvokeMethod(mockType, null, "GetAllPendingScreenshots", It.IsAny <BindingFlags>())) .Returns(_pendingScreenshots); _executionEndingProcessor = new ExecutionEndingProcessor(_mockMethodExecutor.Object, mockAssemblyLoader.Object, mockReflectionWrapper.Object); }
public void ShouldNotBeRecoverableWhenContinueOnFailureOnNonStep() { var assemblyLoader = new Mock <IAssemblyLoader>(); var bazMethod = new MockMethodBuilder(assemblyLoader) .WithName("Baz") .WithContinueOnFailure() .WithParameters(new KeyValuePair <string, string>("string", "Bar")) .Build(); Assert.False(bazMethod.IsRecoverableStep(assemblyLoader.Object), "Recoverable is true only when method is a Step"); }
public void ShouldGetFullyQualifiedName() { var assemblyLoader = new Mock <IAssemblyLoader>(); var fooMethod = new MockMethodBuilder(assemblyLoader) .WithName("Foo") .WithDeclaringTypeName("My.Test.Type") .WithStep("Foo") .Build(); Assert.AreEqual("My.Test.Type.Foo", fooMethod.FullyQuallifiedName()); }
public void ShouldBeRecoverableWhenContinueOnFailure() { var assemblyLoader = new Mock <IAssemblyLoader>(); var barMethod = new MockMethodBuilder(assemblyLoader) .WithName("Bar") .WithStep("Bar") .WithContinueOnFailure() .WithParameters(new KeyValuePair <string, string>("string", "Bar")) .Build(); Assert.True(barMethod.IsRecoverableStep(assemblyLoader.Object)); }
public void ShouldGetFullyQualifiedNameWithParams() { var assemblyLoader = new Mock <IAssemblyLoader>(); var barMethod = new MockMethodBuilder(assemblyLoader) .WithName("Bar") .WithStep("Bar") .WithDeclaringTypeName("My.Test.Type") .WithContinueOnFailure() .WithParameters(new KeyValuePair <string, string>("String", "bar")) .Build(); Assert.AreEqual("My.Test.Type.Bar-Stringbar", barMethod.FullyQuallifiedName()); }
public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); var mockSandbox = new Mock <ISandbox>(); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var mockMessageCollectorType = new Mock <Type>(); mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)) .Returns(mockMessageCollectorType.Object); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.AfterStepHooks).Returns(hooks); var stepExecutionEndingRequest = new StepExecutionEndingRequest { CurrentExecutionInfo = new ExecutionInfo { CurrentSpec = new SpecInfo(), CurrentScenario = new ScenarioInfo() } }; _request = new Message { MessageType = Message.Types.MessageType.StepExecutionEnding, MessageId = 20, StepExecutionEndingRequest = stepExecutionEndingRequest }; _mockMethodExecutor = new Mock <IMethodExecutor>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false, Message = {} }; _mockMethodExecutor.Setup(x => x.ExecuteHooks("AfterStep", It.IsAny <TaggedHooksFirstStrategy>(), new List <string>())) .Returns(_protoExecutionResult); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper.Setup(x => x.InvokeMethod(mockMessageCollectorType.Object, null, "GetAllPendingMessages", BindingFlags.Static | BindingFlags.Public)) .Returns(_pendingMessages); _stepExecutionEndingProcessor = new StepExecutionEndingProcessor(_mockMethodExecutor.Object, mockAssemblyLoader.Object, mockReflectionWrapper.Object); }
public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); var mockSandbox = new Mock <ISandbox>(); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.AfterSuiteHooks).Returns(hooks); var executionEndingRequest = new ExecutionEndingRequest { CurrentExecutionInfo = new ExecutionInfo { CurrentSpec = new SpecInfo(), CurrentScenario = new ScenarioInfo() } }; _request = new Message { MessageId = 20, MessageType = Message.Types.MessageType.ExecutionEnding, ExecutionEndingRequest = executionEndingRequest }; _mockMethodExecutor = new Mock <IMethodExecutor>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false }; _protoExecutionResult.Message.AddRange(_pendingMessages); _mockMethodExecutor.Setup(x => x.ExecuteHooks("AfterSuite", It.IsAny <HooksStrategy>(), It.IsAny <IList <string> >(), It.IsAny <Gauge.CSharp.Lib.ExecutionContext>())) .Returns(_protoExecutionResult); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); _executionEndingProcessor = new ExecutionEndingProcessor(_mockMethodExecutor.Object, mockAssemblyLoader.Object, mockReflectionWrapper.Object); }
public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var mockMessageCollectorType = new Mock <Type>(); var mockScreenshotFilesCollectorType = new Mock <Type>(); mockAssemblyLoader.Setup(x => x.GetLibType(LibType.MessageCollector)) .Returns(mockMessageCollectorType.Object); mockAssemblyLoader.Setup(x => x.GetLibType(LibType.ScreenshotFilesCollector)) .Returns(mockScreenshotFilesCollectorType.Object); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.AfterStepHooks).Returns(hooks); _stepExecutionEndingRequest = new StepExecutionEndingRequest { CurrentExecutionInfo = new ExecutionInfo { CurrentSpec = new SpecInfo(), CurrentScenario = new ScenarioInfo() } }; _mockMethodExecutor = new Mock <IExecutionOrchestrator>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false }; _mockMethodExecutor.Setup(x => x.ExecuteHooks("AfterStep", 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); _stepExecutionEndingProcessor = new StepExecutionEndingProcessor(_mockMethodExecutor.Object); }
public void ShoudExecuteHooksWithExecutionContext() { var mockInstance = new Mock <object>().Object; var mockClassInstanceManagerType = new Mock <Type>().Object; var mockClassInstanceManager = new ThreadLocal <object>(() => new Mock <object>().Object); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var type = LibType.BeforeSuite; var methodInfo = new MockMethodBuilder(mockAssemblyLoader) .WithName($"{type}Hook") .WithFilteredHook(type) .WithDeclaringTypeName("my.foo.type") .WithParameters(new KeyValuePair <Type, string>(typeof(ExecutionContext), "context")) .Build(); mockAssemblyLoader.Setup(x => x.GetMethods(type)).Returns(new List <MethodInfo> { methodInfo }); mockAssemblyLoader.Setup(x => x.ClassInstanceManagerType).Returns(mockClassInstanceManagerType); var executionInfo = new ExecutionInfo(); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper .Setup(x => x.InvokeMethod(mockClassInstanceManagerType, mockClassInstanceManager, "Get", methodInfo.DeclaringType)) .Returns(mockInstance); var expectedExecutionInfo = new ExecutionContext(); var mockExecutionInfoMapper = new Mock <IExecutionInfoMapper>(); mockExecutionInfoMapper.Setup(x => x.ExecutionContextFrom(executionInfo)) .Returns(expectedExecutionInfo); mockReflectionWrapper.Setup(x => x.Invoke(methodInfo, mockInstance, expectedExecutionInfo)) .Verifiable(); var executor = new HookExecutor(mockAssemblyLoader.Object, mockReflectionWrapper.Object, mockClassInstanceManager, mockExecutionInfoMapper.Object); var result = executor.Execute("BeforeSuite", new HooksStrategy(), new List <string>(), executionInfo); Assert.True(result.Success, $"Hook execution failed: {result.ExceptionMessage}\n{result.StackTrace}"); mockReflectionWrapper.VerifyAll(); }
public void ShouldAllowMultipleHooksInaMethod() { var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("MultipleHookMethod") .WithFilteredHook(LibType.BeforeScenario) .WithFilteredHook(LibType.BeforeSpec) .Build(); var beforeScenarioHook = new HookMethod(LibType.BeforeScenario, mockMethod, mockAssemblyLoader.Object); Assert.AreEqual("MultipleHookMethod", beforeScenarioHook.Method); var beforeSpecHook = new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object); Assert.AreEqual("MultipleHookMethod", beforeSpecHook.Method); }
public void ShoudExecuteHooksAndGetTheError() { var mockInstance = new Mock <object>().Object; var mockClassInstanceManagerType = new Mock <Type>().Object; var mockClassInstanceManager = new ThreadLocal <object>(() => new Mock <object>().Object); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var type = LibType.BeforeSuite; var methodInfo = new MockMethodBuilder(mockAssemblyLoader) .WithName($"{type}Hook") .WithFilteredHook(type) .WithDeclaringTypeName("my.foo.type") .Build(); mockAssemblyLoader.Setup(x => x.GetMethods(type)).Returns(new List <MethodInfo> { methodInfo }); mockAssemblyLoader.Setup(x => x.ClassInstanceManagerType).Returns(mockClassInstanceManagerType); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper .Setup(x => x.InvokeMethod(mockClassInstanceManagerType, mockClassInstanceManager, "Get", methodInfo.DeclaringType)) .Returns(mockInstance); var mockExecutionInfoMapper = new Mock <IExecutionInfoMapper>(); mockExecutionInfoMapper.Setup(x => x.ExecutionContextFrom(It.IsAny <ExecutionInfo>())) .Returns(new { Foo = "bar" }); var executor = new HookExecutor(mockAssemblyLoader.Object, mockReflectionWrapper.Object, mockClassInstanceManager, mockExecutionInfoMapper.Object); mockReflectionWrapper.Setup(x => x.Invoke(methodInfo, mockInstance)) .Throws(new Exception("hook failed")); var result = executor.Execute("BeforeSuite", new HooksStrategy(), new List <string>(), new ExecutionInfo()); Assert.False(result.Success, "Hook execution passed, expected failure"); Assert.AreEqual(result.ExceptionMessage, "hook failed"); }
public void ShoudExecuteStepAndGetRecoverableError() { var mockInstance = new Mock <object>().Object; var mockClassInstanceManagerType = new Mock <Type>().Object; var mockClassInstanceManager = new ThreadLocal <object>(() => new Mock <object>().Object); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var methodInfo = new MockMethodBuilder(mockAssemblyLoader) .WithName("StepImplementation") .WithContinueOnFailure() .WithDeclaringTypeName("my.foo.type") .Build(); var gaugeMethod = new GaugeMethod { Name = "StepImplementation", MethodInfo = methodInfo, ContinueOnFailure = true }; mockAssemblyLoader.Setup(x => x.ClassInstanceManagerType).Returns(mockClassInstanceManagerType); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper .Setup(x => x.InvokeMethod(mockClassInstanceManagerType, mockClassInstanceManager, "Get", methodInfo.DeclaringType)) .Returns(mockInstance); var executor = new StepExecutor(mockAssemblyLoader.Object, mockReflectionWrapper.Object, mockClassInstanceManager); mockReflectionWrapper.Setup(x => x.Invoke(methodInfo, mockInstance)) .Throws(new Exception("step execution failure")); var result = executor.Execute(gaugeMethod); Assert.False(result.Success); Assert.True(result.Recoverable); Assert.AreEqual(result.ExceptionMessage, "step execution failure"); }
public void ShoudExecuteHooks() { var mockInstance = new Mock <object>().Object; var mockClassInstanceManagerType = new Mock <Type>().Object; var mockClassInstanceManager = new Mock <object>().Object; var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var type = LibType.BeforeSuite; var methodInfo = new MockMethodBuilder(mockAssemblyLoader) .WithName($"{type}Hook") .WithFilteredHook(type) .WithDeclaringTypeName("my.foo.type") .Build(); mockAssemblyLoader.Setup(x => x.GetMethods(type)).Returns(new List <MethodInfo> { methodInfo }); mockAssemblyLoader.Setup(x => x.ClassInstanceManagerType).Returns(mockClassInstanceManagerType); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper .Setup(x => x.InvokeMethod(mockClassInstanceManagerType, mockClassInstanceManager, "Get", methodInfo.DeclaringType)) .Returns(mockInstance); var executor = new HookExecutor(mockAssemblyLoader.Object, mockReflectionWrapper.Object, mockClassInstanceManager); mockReflectionWrapper.Setup(x => x.Invoke(methodInfo, mockInstance, new List <object>())) .Returns(null); var result = executor.Execute("BeforeSuite", new HooksStrategy(), new List <string>(), new ExecutionContext()); Assert.True(result.Success); }
public void Setup() { var mockHookRegistry = new Mock <IHookRegistry>(); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var mockMethod = new MockMethodBuilder(mockAssemblyLoader) .WithName("Foo") .WithFilteredHook(LibType.BeforeSpec) .Build(); var hooks = new HashSet <IHookMethod> { new HookMethod(LibType.BeforeSpec, mockMethod, mockAssemblyLoader.Object) }; mockHookRegistry.Setup(x => x.BeforeSuiteHooks).Returns(hooks); var executionEndingRequest = new ExecutionStartingRequest(); _request = new Message { MessageId = 20, MessageType = Message.Types.MessageType.ExecutionEnding, ExecutionStartingRequest = executionEndingRequest }; _mockMethodExecutor = new Mock <IExecutionOrchestrator>(); _protoExecutionResult = new ProtoExecutionResult { ExecutionTime = 0, Failed = false }; _mockMethodExecutor.Setup(x => x.ExecuteHooks("BeforeSuite", It.IsAny <HooksStrategy>(), new List <string>(), It.IsAny <ExecutionContext>())) .Returns(_protoExecutionResult); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); _executionStartingProcessor = new ExecutionStartingProcessor(_mockMethodExecutor.Object, mockAssemblyLoader.Object, mockReflectionWrapper.Object); }
public void ShoudExecuteStep() { var mockInstance = new Mock <object>().Object; var mockClassInstanceManagerType = new Mock <Type>().Object; var mockClassInstanceManager = new ThreadLocal <object>(() => new Mock <object>().Object); var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var methodInfo = new MockMethodBuilder(mockAssemblyLoader) .WithName("StepImplementation") .WithDeclaringTypeName("my.foo.type") .Build(); var gaugeMethod = new GaugeMethod { Name = "StepImplementation", MethodInfo = methodInfo }; mockAssemblyLoader.Setup(x => x.ClassInstanceManagerType).Returns(mockClassInstanceManagerType); var mockReflectionWrapper = new Mock <IReflectionWrapper>(); mockReflectionWrapper .Setup(x => x.InvokeMethod(mockClassInstanceManagerType, mockClassInstanceManager, "Get", methodInfo.DeclaringType)) .Returns(mockInstance); var executor = new StepExecutor(mockAssemblyLoader.Object, mockReflectionWrapper.Object, mockClassInstanceManager); mockReflectionWrapper.Setup(x => x.Invoke(methodInfo, mockInstance)) .Returns(null); var result = executor.Execute(gaugeMethod); Assert.True(result.Success); }
public void Setup() { IHookMethod Create(string name, int aggregation = 0, params string[] tags) { var mockAssemblyLoader = new Mock <IAssemblyLoader>(); var method = new MockMethodBuilder(mockAssemblyLoader) .WithName(name) .WithDeclaringTypeName("my.foo.type") .WithTagAggregation(aggregation) .WithFilteredHook(LibType.AfterScenario, tags) .Build(); return(new HookMethod(LibType.AfterScenario, method, mockAssemblyLoader.Object)); } _hookMethods = new HashSet <IHookMethod> { Create("Foo", 0, "Foo"), Create("Bar", 0, "Foo", "Bar"), Create("Zed", 1), Create("Blah"), Create("Baz") }; }