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