private Dictionary<String, Object> getActualArguments(CommandDescriptor commandDescriptor, CommandCallDescriptor commandCallDescriptor) { // order arguments by position var positionedArguments = commandCallDescriptor.ActualParameters .OfType<PositionedCommandCallActualArgument>() .OrderBy(argument => argument.Position); // try to match formal and actual arguments to each other var zippedArguments = commandDescriptor.Arguments.Zip(positionedArguments, (formalArg, actualArg) => new { FormalArgument = formalArg, ActualArgument = actualArg }); // filter not matching types zippedArguments = zippedArguments.Where(arguments => { if (arguments.ActualArgument.Value == null) { return arguments.FormalArgument.ArgumentType == typeof (Object); } return arguments.FormalArgument.ArgumentType == arguments.ActualArgument.Value.GetType() && arguments.FormalArgument.Position == arguments.ActualArgument.Position; }); return zippedArguments.ToDictionary( arguments => arguments.FormalArgument.ArgumentName, arguments => arguments.ActualArgument.Value); }
private Command getCommand(CommandCallElement commandCallElement) { var actualParameters = commandCallElement.ActualParameters.Select(Create); var descriptor = new CommandCallDescriptor(commandCallElement.MethodName, actualParameters); return(CommandCallResolver.CreateCommand(descriptor)); }
/// <summary> /// Creates the command. /// </summary> /// <param name="descriptor"></param> /// <returns>Returns created command or null</returns> public Command CreateCommand(CommandCallDescriptor descriptor) { Assume.NotNull(descriptor, nameof(descriptor)); // get command descriptor from manager var commandDescriptors = resolveCommandDescriptorsByName(descriptor); var commandDescriptor = resolveCommandDescriptorByParameters(commandDescriptors, descriptor); // if there is no proper command descriptor return null if (commandDescriptor == null) { return null; } // get actual parameters var actualArguments = getActualArguments(commandDescriptor, descriptor); // create runnable with factory var runnable = RunnableFactory.Create(commandDescriptor.Name, actualArguments); // create a command instance var command = new Command(runnable, commandDescriptor, actualArguments); return command; }
public void Equals_ShouldReturnFalse_WhenItIsComparedWithNullValue() { // Given var underTest = new CommandCallDescriptor("test-call", Enumerable.Empty <ICommandCallActualArgument>()); // When var result = underTest.Equals(null); // Then Assert.That(result, Is.False); }
public void Equals_ShouldReturnTrue_WhenSameReferencesAreCompared() { // Given var underTest = new CommandCallDescriptor("test-call", Enumerable.Empty <ICommandCallActualArgument>()); // When var result = underTest.Equals(underTest); // Then Assert.That(result, Is.True); }
public void Equals_ShouldReturnFalse_WhenItIsComparedWithNullValue() { // Given var underTest = new CommandCallDescriptor("test-call", Enumerable.Empty<ICommandCallActualArgument>()); // When var result = underTest.Equals(null); // Then Assert.That(result, Is.False); }
public void Equals_ShouldReturnTrue_WhenSameReferencesAreCompared() { // Given var underTest = new CommandCallDescriptor("test-call", Enumerable.Empty<ICommandCallActualArgument>()); // When var result = underTest.Equals(underTest); // Then Assert.That(result, Is.True); }
public void CreateCommand_ShouldCreateCommand_WhenCommandIsNotFound() { // Given in setup var arguments = new[] { new PositionedCommandCallActualArgument(0, false), new PositionedCommandCallActualArgument(1, "Hello World") }; var commandCallDescriptor = new CommandCallDescriptor("test-command", arguments); // When var result = UnderTest.CreateCommand(commandCallDescriptor); // Then Assert.That(result, Is.Null); }
private CommandDescriptor resolveCommandDescriptorByParameters(IEnumerable<CommandDescriptor> commandDescriptors, CommandCallDescriptor commandCallDescriptor) { foreach (var commandDescriptor in commandDescriptors) { // check parameters count equality (note: this class does not handle optional or named parameters // if it is not equal jump to the next one if (commandDescriptor.Arguments.Count() != commandCallDescriptor.ActualParameters.Count()) { continue; } // get positioned arguments from command call descriptor var positionedArguments = commandCallDescriptor.ActualParameters .OfType<PositionedCommandCallActualArgument>() .OrderBy(argument => argument.Position); // zip to array into one to find matching argument lists var result = commandDescriptor.Arguments.Zip(positionedArguments, (argument, actualArgument) => { if (actualArgument.Value == null) { return new { FormalArgumentType = argument.ArgumentType, ActualArgumentType = typeof (Object) }; // return Tuple.Create(argument.ArgumentType, typeof (Object)); } return new { FormalArgumentType = argument.ArgumentType, ActualArgumentType = actualArgument.Value.GetType() }; // return Tuple.Create(argument.ArgumentType, actualArgument.Value.GetType()); }); // if there is a match then return with the result if (result.All(tuple => tuple.ActualArgumentType == tuple.FormalArgumentType)) { return commandDescriptor; } } return null; }
private IEnumerable<CommandDescriptor> resolveCommandDescriptorsByName(CommandCallDescriptor descriptor) { // get all available command descriptors var commandDescriptors = DescriptorRepository.GetCommandDescriptors(); // filter command descriptors by their command name var filteredDescriptors = commandDescriptors.Where(commandDescriptor => commandDescriptor.CommandNames.Contains(descriptor.Name)); return filteredDescriptors.ToList(); }
/// <summary> /// Creates the command. /// </summary> public Command CreateCommand(CommandCallDescriptor descriptor) { return new Command(new DummyRunnable(), _fixture.Create<CommandDescriptor>()); }
/// <summary> /// Creates the command. /// </summary> public Command CreateCommand(CommandCallDescriptor descriptor) { return(new Command(new DummyRunnable(), _fixture.Create <CommandDescriptor>())); }