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 ParameterAttribute(string shortName, string description, bool isRequire = false, Type convertType = null)
{
ShortName = shortName;
IsRequire = isRequire;
Description = description;
if (convertType != null)
{
Converter = ActivatorWrapper.SolveInstance(convertType).ResolveService <IValueConverter>();
}
}
public void _01_SHOULD_return_a_DummyClass_instance()
{
string stringPropertyValue = "Sat Sri Akal!";
ActivatorWrapper wrapper = new ActivatorWrapper();
DummyClass expectedDummy;
expectedDummy = wrapper.CreateInstance(typeof(DummyClass), new object[] { stringPropertyValue }) as DummyClass;
Assert.That(expectedDummy.StringProperty, Is.EqualTo(stringPropertyValue));
}
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 DisposeService RegisterTask <T>() where T : DisposeTask
{
var t = ActivatorWrapper.SolveInstance <T>();
if (Task.Any(o => o.GetType() == typeof(T)))
{
this.Info(typeof(T).FullName + " is already registed!!");
}
this.Info("Registed Dispose Service" + typeof(T).FullName);
Task.Add(t);
return(this);
}
internal static void Configurate(params Type[] tasks)
{
Tasks.Clear();
foreach (var task in tasks)
{
if (task.IsSubclassOf(InitaializeType))
{
var taskinstance = (InitializeTask)ActivatorWrapper.SolveInstance(task, null);
taskinstance.ProgressChanged += (s, e) => { RasizeProgressChanged(e.Progress); };
Tasks.Add(taskinstance);
}
}
}
public void ShouldGetStepTextsForMethod()
{
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 registry = assemblyLoader.GetStepRegistry();
var gaugeMethod = registry.MethodFor("and an alias");
var stepTexts = gaugeMethod.Aliases.ToList();
Assert.Contains("Step with text", stepTexts);
Assert.Contains("and an alias", stepTexts);
}
public void ShouldRefactorAttributeText()
{
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods().First(info =>
info.Name == "IntegrationTestSample.RefactoringSample.RefactoringContext");
sandbox.Refactor(gaugeMethod, new List <Tuple <int, int> >(), new List <string>(), "foo");
AssertStepAttributeWithTextExists(gaugeMethod.Name, "foo");
}
public void ShouldRefactorAndReturnFilesChanged()
{
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods().First(info =>
info.Name == "IntegrationTestSample.RefactoringSample.RefactoringContext");
var expectedPath = Path.GetFullPath(Path.Combine(_testProjectPath, "RefactoringSample.cs"));
var changedFile =
sandbox.Refactor(gaugeMethod, new List <Tuple <int, int> >(), new List <string>(), "foo").ToList();
Assert.AreEqual(expectedPath, changedFile);
}
public void ShouldRemoveParametersInAnyOrder()
{
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods().First(info =>
info.Name == "IntegrationTestSample.RefactoringSample.RefactoringSaySomething-StringwhatStringwho");
var parameterPositions = new[] { new Tuple <int, int>(1, 0) };
sandbox.Refactor(gaugeMethod, parameterPositions, new List <string>(), "Refactoring Say something to <who>");
AssertParametersExist(gaugeMethod.Name, new[] { "who" });
}
public void StartServer()
{
var server = new Server();
var assemblies = new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies();
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), assemblies, reflectionWrapper, activatorWrapper, _staticLoader.GetStepRegistry());
var handler = new RunnerServiceHandler(activatorWrapper, reflectionWrapper, assemblyLoader, _staticLoader, server);
server.Services.Add(Runner.BindService(handler));
var port = server.Ports.Add(new ServerPort("127.0.0.1", 0, ServerCredentials.Insecure));
server.Start();
Console.WriteLine("Listening on port:" + port);
server.ShutdownTask.Wait();
Environment.Exit(Environment.ExitCode);
}
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 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 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 ShouldReorderParameters()
{
const string newStepValue = "Refactoring Say <who> to <what>";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods().First(info =>
info.Name == "IntegrationTestSample.RefactoringSample.RefactoringSaySomething-StringwhatStringwho");
var parameterPositions = new[] { new Tuple <int, int>(0, 1), new Tuple <int, int>(1, 0) };
sandbox.Refactor(gaugeMethod, parameterPositions, new List <string> {
"who", "what"
}, newStepValue);
AssertStepAttributeWithTextExists(gaugeMethod.Name, newStepValue);
AssertParametersExist(gaugeMethod.Name, new[] { "who", "what" });
}
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 ShouldAddParametersWithReservedKeywordName()
{
const string newStepValue = "Refactoring this is a test step <class>";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods().First(info =>
info.Name == "IntegrationTestSample.RefactoringSample.RefactoringSampleTest");
var parameterPositions = new[] { new Tuple <int, int>(-1, 0) };
sandbox.Refactor(gaugeMethod, parameterPositions, new List <string> {
"class"
}, newStepValue);
AssertStepAttributeWithTextExists(gaugeMethod.Name, newStepValue);
AssertParametersExist(gaugeMethod.Name, new[] { "@class" });
}
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 sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods()
.First(method => method.Name == "IntegrationTestSample.StepImplementation.ThrowSerializableException");
var scannedSteps = new List <KeyValuePair <string, GaugeMethod> >
{
new KeyValuePair <string, GaugeMethod>(parameterizedStepText, gaugeMethod)
};
var aliases = new Dictionary <string, bool> {
{ parameterizedStepText, false }
};
var stepTextMap = new Dictionary <string, string> {
{ parameterizedStepText, stepText }
};
var stepRegistry = new StepRegistry(scannedSteps, stepTextMap, aliases);
var executeStepProcessor = new ExecuteStepProcessor(stepRegistry, new MethodExecutor(sandbox), 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(Encoding.UTF8.GetString(protoExecutionResult.ScreenShot.ToByteArray()), "ScreenShot");
}
internal static async void Initialize(string[] args)
{
try
{
var appentry = ActivatorWrapper.SolveInstance <T>();
AdapterInitialize(appentry.InitializeTask);
var isSucc = false;
if (appentry.SplashEnabled)
{
var splashWindow = (Window)ActivatorWrapper.SolveInstance(appentry.SplashWindowType);
splashWindow.Show();
isSucc = await Task.Run(() => InitializeTaskFatory.ExcuteInitialize());
splashWindow.Close();
}
else
{
isSucc = await Task.Run(() => InitializeTaskFatory.ExcuteInitialize());
}
if (isSucc)
{
var mainWindow = (BootstrapWindow)ActivatorWrapper.SolveInstance(appentry.MainWindowtype);
mainWindow.Closed += MainWindow_Closed;
Application.Current.MainWindow = mainWindow;
mainWindow.Show();
}
else
{
MessageBox.Show("系统任务初始化错误,程序关闭", "错误提示");
Application.Current.Shutdown();
}
}
catch (Exception ex)
{
MessageBox.Show("系统初始化错误：" + ex.Message, "错误提示");
LogExtensions.Critical(null, ex);
Application.Current.Shutdown();
}
}
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 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 static IGaugeCommand GetExecutor(string phase)
{
switch (phase)
{
case "--init":
return(new SetupCommand());
default:
return(new StartCommand(() =>
{
using (var apiConnection = new GaugeApiConnection(new TcpClientWrapper(Utils.GaugeApiPort)))
{
var reflectionWrapper = new ReflectionWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var activatorWrapper = new ActivatorWrapper();
var sandBox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var methodScanner = new MethodScanner(apiConnection, sandBox);
var messageProcessorFactory = new MessageProcessorFactory(methodScanner, sandBox, assemblyLoader, activatorWrapper, new TableFormatter(assemblyLoader, activatorWrapper), reflectionWrapper);
return new GaugeListener(messageProcessorFactory);
}
},
() => new GaugeProjectBuilder()));
}
}
private void StartAppTask()
{
ActivatorWrapper.SolveInstance <InternalApp <T> >().Run();
}
public void ShouldAddParameters()
{
const string parameterizedStepText = "Refactoring 1 Say <what> to <who>";
const string stepValue = "Refactoring 1 Say {} to {}";
var reflectionWrapper = new ReflectionWrapper();
var activatorWrapper = new ActivatorWrapper();
var assemblyLoader = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
var sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods()
.First(method =>
method.Name ==
"IntegrationTestSample.RefactoringSample.RefactoringSaySomething1-StringwhatStringwho");
var scannedSteps =
new List <KeyValuePair <string, GaugeMethod> >
{
new KeyValuePair <string, GaugeMethod>(stepValue, gaugeMethod)
};
var aliases = new Dictionary <string, bool> {
{ stepValue, false }
};
var stepTextMap = new Dictionary <string, string> {
{ stepValue, parameterizedStepText }
};
var stepRegistry = new StepRegistry(scannedSteps, stepTextMap, aliases);
var message = new Message
{
MessageId = 1234,
MessageType = Message.Types.MessageType.RefactorRequest,
RefactorRequest = new RefactorRequest
{
OldStepValue = new ProtoStepValue
{
StepValue = stepValue,
ParameterizedStepValue = parameterizedStepText,
Parameters = { "what", "who" }
},
NewStepValue = new ProtoStepValue
{
StepValue = "Refactoring 1 Say {} to {} at {}",
ParameterizedStepValue = "Refactoring 1 Say <what> to <who> at <when>",
Parameters = { "who", "what", "when" }
},
ParamPositions =
{
new ParameterPosition {
OldPosition = 0, NewPosition = 0
},
new ParameterPosition {
OldPosition = 1, NewPosition = 1
},
new ParameterPosition {
OldPosition = -1, NewPosition = 2
}
}
}
};
var refactorProcessor = new RefactorProcessor(stepRegistry, sandbox);
var result = refactorProcessor.Process(message);
Assert.IsTrue(result.RefactorResponse.Success);
}
public static void StartSession()
{
ActivatorWrapper.SolveInstance <AppTaskGenerator <T> >().Run();
InstanseManager.ResolveService <DisposeService>().Dispose();
LogExtensions.Info(null, "Application Session End");
}
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 sandbox = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
var gaugeMethod = sandbox.GetStepMethods()
.First(method => method.Name == "IntegrationTestSample.StepImplementation.ReadTable-Tabletable");
var scannedSteps = new List <KeyValuePair <string, GaugeMethod> >
{
new KeyValuePair <string, GaugeMethod>(parameterizedStepText, gaugeMethod)
};
var aliases = new Dictionary <string, bool> {
{ parameterizedStepText, false }
};
var stepTextMap = new Dictionary <string, string> {
{ parameterizedStepText, stepText }
};
var stepRegistry = new StepRegistry(scannedSteps, stepTextMap, aliases);
var executeStepProcessor = new ExecuteStepProcessor(stepRegistry, new MethodExecutor(sandbox), 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);
}
