public override void Setup()
{
base.Setup();
var commands = new[]
{
new CommandDescriptor("IdentityRunnable", String.Empty, Enumerable.Empty<ArgumentDescriptor>(), new[] {"IdentityRunnable"}),
new CommandDescriptor("IncrementRunnable", String.Empty, new[]
{
new ArgumentDescriptor
{
ArgumentType = typeof (Double),
ArgumentName = "value",
DefaultValue = 0,
IsOptional = false,
Position = 0
}
}, new[] {"IncrementRunnable", "increment", "inc"})
};
var runnableFactory = new DefaultRunnableFactory(new[] {typeof (IdentityRunnable), typeof (IncrementRunnable)});
var repository = new MemoryDescriptorRepository(commandDescriptors: commands);
var commandCallResolver = new DefaultCommandCallResolver(repository, runnableFactory);
var selectorManager = new DefaultSelectorFactory();
var nodeSelectorResolver = new DefaultSelectorResolver(selectorManager, repository);
var runnableManager = new DefaultRunnableManager();
var executor = new StandardExecutor(runnableManager);
// initialize compiler and control flow factory
ControlFlowFactory = new DefaultControlFlowFactory(commandCallResolver, nodeSelectorResolver, executor);
Compiler = new CodeQueryCompiler();
}
public void Parse_ShouldParseHandle_WhenSelectorsAreDefined(String command)
{
// Given
var underTest = new CodeQueryCompiler();
// When
var result = underTest.Parse(command);
// Then
Assert.That(result, Is.Not.Null);
}
public void Parse_ShouldParseCommand_WhenSimpleCommandCallIsPassed()
{
// Given
var underTest = new CodeQueryCompiler();
// When
var result = underTest.Parse("@test-command");
// Then
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf<CommandCallControlFlowElement>());
}
public void Parse_ShouldReturnSequenceControlFlow_WhenMultipleCommandsArePassed()
{
// Given
var underTest = new CodeQueryCompiler();
// When
var result = underTest.Parse("@test-command; @test-command-2") as SequenceControlFlowElement;
// Then
Assert.That(result, Is.Not.Null);
var expectedChildren = result.Children
.Cast<CommandCallControlFlowElement>()
.Select(call => call.CommandCallElement.MethodName);
Assert.That(expectedChildren, Is.EquivalentTo(new[] { "test-command", "test-command-2" }));
}
public void Parse_ShouldParseCommand_WhenSimpleCommandCallWithOneStringParameterIsPassed()
{
// Given
var underTest = new CodeQueryCompiler();
// When
var result = underTest.Parse("@test-command \"hello world!\"") as CommandCallControlFlowElement;
// Then
Assert.That(result, Is.Not.Null);
var actualParameters = result.CommandCallElement.ActualParameters.ToArray();
Assert.That(actualParameters.Length, Is.EqualTo(1));
Assert.That(actualParameters.Select(parameter => new {
Position = parameter.Position,
Value = parameter.Value.Value as String
}), Is.EquivalentTo(new[] { new { Position = Option.Some(0), Value = "hello world!" } }));
}
/// <summary>
/// Initializes a new instance of the <see cref="Bootstrapper"/> class.
/// </summary>
public Bootstrapper(IRunnableFactory runnableFactory, IDescriptorRepository descriptorRepository, Func<Bootstrapper, ICommandDescriptorManager> commandDescriptorManager = null,
Func<Bootstrapper, ICommandCallResolver> commandResolver = null, Func<Bootstrapper, ISelectorFactory> selectorFactory = null,
Func<Bootstrapper, ISelectorResolver> selectorResolver = null, Func<Bootstrapper, IRunnableManager> runnableManager = null, Func<Bootstrapper, IExecutor> executor = null,
Func<Bootstrapper, IControlFlowFactory<ControlFlowBase>> controlFlowFactory = null)
{
Assume.NotNull(runnableFactory, nameof(runnableFactory));
Assume.NotNull(descriptorRepository, nameof(descriptorRepository));
RunnableFactory = runnableFactory;
DescriptorRepository = descriptorRepository;
CommandDescriptorManager = commandDescriptorManager.SafeInvoke(this) ?? new DefaultCommandDescriptorManager();
CommandCallResolver = commandResolver.SafeInvoke(this) ?? new DefaultCommandCallResolver(descriptorRepository, RunnableFactory);
SelectorFactory = selectorFactory.SafeInvoke(this) ?? new DefaultSelectorFactory();
SelectorResolver = selectorResolver.SafeInvoke(this) ?? new DefaultSelectorResolver(SelectorFactory, DescriptorRepository);
RunnableManager = runnableManager.SafeInvoke(this) ?? new DefaultRunnableManager();
Executor = executor.SafeInvoke(this) ?? new StandardExecutor(RunnableManager);
ControlFlowFactory = controlFlowFactory.SafeInvoke(this) ?? new DefaultControlFlowFactory(CommandCallResolver, SelectorResolver, Executor);
Compiler = new CodeQueryCompiler();
}