public void TestExecuteSync()
{
var processor = new MockCommandProcessor();
var command = new MockCommand(true);
processor.Init(Assert.IsNull);
Assert.IsFalse(processor.Execute(1, command)); //new state should be false
}
public void TestExecuteAsync()
{
var processor = new MockCommandProcessor();
var command = new MockCommand(true);
processor.Init(Assert.IsNull);
bool newState = processor.ExecuteAsync(1, command).ConfigureAwait(true).GetAwaiter().GetResult();
Assert.IsFalse(newState); //new state should be false
}
public void TestExecuteAndForget()
{
var command = new MockCommand(true);
var processor = new MockCommandProcessor();
processor.Init(Assert.IsNull);
processor.ExecuteAndForget(1, command);
Assert.IsTrue(SpinWaitHelper.SpinWaitForCondition(() => command.CurrentState == false, 500));
//new state should be false
}
public void RegisterCommand_AddsCommandToDictionary()
{
// Arrange
CommandManager cm = new CommandManager();
ICommand mockCommand = new MockCommand();
// Act
cm.RegisterCommand(mockCommand);
// Assert
Assert.Equal(1, cm.GetCommands().Count());
}
public void WhenCommandIsSetAndThenBehaviorIsAttached_ThenCommandsCanExecuteIsCalledOnce()
{
var someControl = new TextBox();
var command = new MockCommand();
var commandAction = new InvokeCommandAction();
commandAction.Command = command;
commandAction.Attach(someControl);
Assert.AreEqual(1, command.CanExecuteTimesCalled);
}
public void GetCommand_ReturnsCorrectCommand()
{
// Arrange
CommandManager cm = new CommandManager();
ICommand expectedCommand = new MockCommand();
cm.RegisterCommand(expectedCommand);
// Act
ICommand actualCommand = cm.GetCommand("MockCommand");
// Assert
Assert.Equal(expectedCommand, actualCommand);
}
public void RegisterCommand_AddsCommandToDictionary()
{
// Arrage
CommandManager cm = new CommandManager();
ICommand mockCommand = new MockCommand();
// Act
cm.RegisterCommand(mockCommand);
// Assert
Assert.AreEqual(1, cm.GetCommands().Count());
}
public void ShouldNotThrowWhenCommandSetToNull()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = command;
behavior.Command = null;
clickableObject.RaiseClick();
}
public void KillSwitch_will_have_been_engaged_if_service_method_was_successful_but_synchronization_was_not()
{
//Arrange
MockMethodReturn.Setup(m => m.Success).Returns(true);
MockCommand.Setup(m => m.Synchronize(It.IsAny <Func <TCommandInput> >())).Throws(new Exception());
//Act
SynchronizeOldContext.OnExit(MethodExecutionArgs);
//Assert
MockKillSwitch.Verify(k => k.Engage(), Times.Once());
}
public void FunctionBase_ShouldResolveCommand()
{
var commandObj = new MockCommand();
serviceProviderMock
.Setup(x => x.GetService(It.IsAny <Type>()))
.Returns(commandObj);
var result = functionBase.ResolveCommand <MockCommand>();
result.Should().Be(commandObj);
}
public async Task <MockCommandResult> OnCommand(MockCommand evt)
{
AddCalledHandler(nameof(OnCommand));
var mockResponse = new MockCommandResult();
await Task.Run(() => {
mockResponse.Value = "MOCK_VALUE";
});
return(mockResponse);
}
public void ShouldHookUpClickCommandBehaviorWhenSettingProperty()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
Click.SetCommand(clickableObject, command);
Assert.IsFalse(command.ExecuteCalled);
clickableObject.RaiseClick();
Assert.IsTrue(command.ExecuteCalled);
Assert.AreSame(command, Click.GetCommand(clickableObject));
}
public void GetCommand_ReturnsCorrectCommand()
{
// Arrange
CommandManager cm = new CommandManager();
ICommand expectedCommand = new MockCommand();
cm.RegisterCommand(expectedCommand);
// Act
ICommand actualCommand = cm.GetCommand("MockCommand");
// Assert
Assert.Equal(expectedCommand, actualCommand);
}
public void ShouldGetAndSeReturnKeytProperties()
{
var textBox = new TextBox();
const string defaultText = "Default Text";
var command = new MockCommand();
ReturnKey.SetCommand(textBox, command);
Assert.AreEqual(command, ReturnKey.GetCommand(textBox));
ReturnKey.SetDefaultTextAfterCommandExecution(textBox, defaultText);
Assert.AreEqual(defaultText, ReturnKey.GetDefaultTextAfterCommandExecution(textBox));
}
public void Serialize()
{
var command = new MockCommand(this.user, MockPayload.Instance);
var json = TeamCloudSerialize.SerializeObject(command);
Assert.NotEmpty(json);
Assert.Contains("$type", json);
var resultObj = TeamCloudSerialize.DeserializeObject <ICommand>(json);
Assert.IsType <MockCommand>(resultObj);
}
public void TestExecuteWithCallback()
{
var processor = new MockCommandProcessor();
var command = new MockCommand(true);
var countDown = new CountdownEvent(1);
processor.Init(Assert.IsNull);
processor.Execute(1, command, state =>
{
Assert.IsFalse(state); //new state should be false
countDown.Signal();
});
Assert.IsTrue(countDown.Wait(500));
}
public void ShouldGetAndSeReturnKeytProperties()
{
var textBox = new TextBox();
const string defaultText = "Default Text";
var command = new MockCommand();
ReturnKey.SetCommand(textBox, command);
Assert.AreEqual(command, ReturnKey.GetCommand(textBox));
ReturnKey.SetDefaultTextAfterCommandExecution(textBox, defaultText);
Assert.AreEqual(defaultText, ReturnKey.GetDefaultTextAfterCommandExecution(textBox));
}
public void ShouldUpdateCommandOnBehaviorWhenChangingProperty()
{
var clickableObject = new MockClickableObject();
var oldCommand = new MockCommand();
var newCommand = new MockCommand();
Click.SetCommand(clickableObject, oldCommand);
Click.SetCommand(clickableObject, newCommand);
clickableObject.RaiseClick();
Assert.IsTrue(newCommand.ExecuteCalled);
Assert.IsFalse(oldCommand.ExecuteCalled);
}
public void ShouldObserveClickEvent()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = command;
Assert.IsFalse(command.ExecuteCalled);
clickableObject.RaiseClick();
Assert.IsTrue(command.ExecuteCalled);
}
public void WhenCommandParameterNotSet_ThenEventArgsPassed()
{
var eventArgs = new TestEventArgs(null);
var someControl = new TextBox();
var command = new MockCommand();
var parameter = new object();
var commandAction = new InvokeCommandAction();
commandAction.Command = command;
commandAction.Attach(someControl);
commandAction.InvokeAction(eventArgs);
Assert.IsType <TestEventArgs>(command.ExecuteParameter);
}
public void WhenChangingProperty_ThenUpdatesCommand()
{
var someControl = new TextBox();
var oldCommand = new MockCommand();
var newCommand = new MockCommand();
var commandAction = new InvokeCommandAction();
commandAction.Attach(someControl);
commandAction.Command = oldCommand;
commandAction.Command = newCommand;
commandAction.InvokeAction(null);
Assert.True(newCommand.ExecuteCalled);
Assert.False(oldCommand.ExecuteCalled);
}
public void WhenCommandAndCommandParameterAreSetPriorToBehaviorBeingAttached_ThenCommandIsExecutedCorrectlyOnInvoke()
{
var someControl = new TextBox();
var command = new MockCommand();
var parameter = new object();
var commandAction = new InvokeCommandAction();
commandAction.Command = command;
commandAction.CommandParameter = parameter;
commandAction.Attach(someControl);
commandAction.InvokeAction(null);
Assert.True(command.ExecuteCalled);
}
public void ShouldDisableButtonIfCanExecuteFalse()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand()
{
CanExecuteReturnValue = false
};
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
Assert.IsTrue(clickableObject.IsEnabled);
behavior.Command = command;
Assert.IsFalse(clickableObject.IsEnabled);
}
public void CustomerRepository_GetCustomers_ShouldReturnConcreteList()
{
var list = new List <Customer>
{
new Customer
{
CustomerId = 1,
FirstName = "Bob",
LastName = "Jones",
EmailAddress = "*****@*****.**",
City = "Atlanta",
State = "GA",
Zip = "30339",
Phone = "8881234567"
},
new Customer
{
CustomerId = 1,
FirstName = "Dave",
LastName = "Smith",
EmailAddress = "*****@*****.**",
City = "Seattle",
State = "WA",
Zip = "99939",
Phone = "8884555444"
},
new Customer
{
CustomerId = 1,
FirstName = "Erin",
LastName = "Mitchell",
EmailAddress = "*****@*****.**",
City = "Macon",
State = "GA",
Zip = "39999",
Phone = "8887774567"
},
};
var dt = new DataTableBuilder <Customer>(list)
.ColumnFor(c => c.Zip, "PostalCode")
.Build();
var command = new MockCommand(dt);
var sqlBuilder = new SqlQueryBuilder <Customer>(conn => command, conn => { });
var repository = new CustomerRepository(sqlBuilder);
var customers = repository.GetCustomers();
Assert.True(AreEqual(customers, list));
}
public void ShouldExecuteWithCommandParameter()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var parameter = new object();
Click.SetCommand(clickableObject, command);
Click.SetCommandParameter(clickableObject, parameter);
Assert.IsNull(command.ExecuteParameter);
clickableObject.RaiseClick();
Assert.IsTrue(command.ExecuteCalled);
Assert.IsNotNull(command.ExecuteParameter);
Assert.AreSame(parameter, command.ExecuteParameter);
}
public void WhenAttachedAfterCommandPropertyIsSetAndInvoked_ThenInvokesCommand()
{
var someControl = new TextBox();
var commandAction = new InvokeCommandAction();
var command = new MockCommand();
commandAction.Command = command;
commandAction.Attach(someControl);
Assert.False(command.ExecuteCalled);
commandAction.InvokeAction(null);
Assert.True(command.ExecuteCalled);
Assert.Same(command, commandAction.GetValue(InvokeCommandAction.CommandProperty));
}
public void HelpCommand()
{
var mock = new MockCommand();
this.cmdLine.RegisterCommand(new Program.Command("testhelp", mock.Provider, "", detailedHelp: "line1\nline2", minArgs: 4));
this.cmdLine.StartCmd("-help testhelp", Program.CommandTrigger.Cmd);
this.logs.Clear();
this.manager.Tick();
Assert.AreEqual(3, this.logs.Count);
Assert.AreEqual("-testhelp: takes at least 4 arguments", this.logs[0]);
Assert.AreEqual(" line1", this.logs[1]);
Assert.AreEqual(" line2", this.logs[2]);
}
public void WhenCommandParameterNotSetAndEventArgsParameterPathSet_ThenPathedValuePassed()
{
var eventArgs = new TestEventArgs("testname");
var someControl = new TextBox();
var command = new MockCommand();
var parameter = new object();
var commandAction = new InvokeCommandAction();
commandAction.Command = command;
commandAction.TriggerParameterPath = "Thing1.Thing2.Name";
commandAction.Attach(someControl);
commandAction.InvokeAction(eventArgs);
Assert.Equal("testname", command.ExecuteParameter);
}
public void WhenCommandPropertyIsSet_ThenHooksUpCommandBehavior()
{
var someControl = new TextBox();
var commandAction = new InvokeCommandAction();
var command = new MockCommand();
commandAction.Attach(someControl);
commandAction.Command = command;
Assert.False(command.ExecuteCalled);
commandAction.InvokeAction(null);
Assert.True(command.ExecuteCalled);
Assert.Same(command, commandAction.GetValue(InvokeCommandAction.CommandProperty));
}
public void WhenAttachedAndCanExecuteReturnsFalse_ThenEnabledUIElementIsDisabled()
{
var someControl = new TextBox();
someControl.IsEnabled = true;
var command = new MockCommand();
command.CanExecuteReturnValue = false;
var commandAction = new InvokeCommandAction();
commandAction.Command = command;
commandAction.Attach(someControl);
Assert.False(someControl.IsEnabled);
}
public void ShouldNotMonitorCanExecuteChangedOnDisconnectedCommand()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = command;
behavior.Command = null;
Assert.IsTrue(clickableObject.IsEnabled);
command.CanExecuteReturnValue = false;
command.RaiseCanExecuteChanged();
Assert.IsTrue(clickableObject.IsEnabled);
}
public void WhenAutoEnableIsFalse_ThenEnabledUIElementRemainsEnabled()
{
var someControl = new TextBox();
someControl.IsEnabled = true;
var command = new MockCommand();
command.CanExecuteReturnValue = false;
var commandAction = new InvokeCommandAction();
commandAction.AutoEnable = false;
commandAction.Command = command;
commandAction.Attach(someControl);
Assert.IsTrue(someControl.IsEnabled);
}
public void ShouldExecuteWithCommandParameter()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var parameter = new object();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = command;
behavior.CommandParameter = parameter;
Assert.IsNull(command.ExecuteParameter);
clickableObject.RaiseClick();
Assert.IsTrue(command.ExecuteCalled);
Assert.IsNotNull(command.ExecuteParameter);
Assert.AreSame(parameter, command.ExecuteParameter);
}
public virtual void PerformCommandTest()
{
ConnectionBase conn = CreateConnection("test");
try
{
TcpConnection_Accessor accessor = GetConnectionAccessor(conn);
// assign mock socket
accessor.Socket = new ClientSocketMock();
accessor.Socket.Open();
XmlFormatterFactoryMock factory = new XmlFormatterFactoryMock();
accessor.FormatterFactory = factory;
IBinaryWriter writer = factory.CreateWriter(accessor.DataStream);
// preserialize server protocol version and rewind to start pos. (emulate first stage of handshake procedure)
int protocolVersion = TcpConnection_Accessor.MAJOR_PROTOCOL_VERSION;
writer.Write(protocolVersion);
StreamAdapter_Accessor streamAccessor = GetStreamAccessor((StreamAdapter)accessor.DataStream);
long pos = streamAccessor.Stream.Position;
streamAccessor.Stream.Seek(0, SeekOrigin.Begin);
// command id and version
const ServerCommand id = ServerCommand.Status;
const short ver = 1;
MockCommand command = new MockCommand(conn, id, ver);
accessor.PerformCommand(command);
accessor.Socket.Open();
streamAccessor.Stream.Seek(pos, SeekOrigin.Begin);
IBinaryReader reader = factory.CreateReader(accessor.DataStream);
// skip protocol version sent by hadshake method
int clientProtocol = reader.ReadInt32();
// read & check data sent by mock command code
ServerCommand actualId = (ServerCommand)reader.ReadInt16();
Assert.AreEqual(id, actualId);
short actualVer = reader.ReadInt16();
Assert.AreEqual(ver, actualVer);
}
finally
{
conn.Close();
}
}
public void Test()
{
var collector = new CommandCollector();
var command1 = new MockCommand();
collector.Execute(command1);
command1.Executed.Should().BeTrue(because: "Should execute while collecting");
var command2 = new MockCommand();
collector.Execute(command2);
command2.Executed.Should().BeTrue(because: "Should execute while collecting");
var composite = collector.BuildComposite();
composite.Execute();
composite.Undo();
command1.Executed.Should().BeFalse(because: "Should undo as part of composite");
// ReSharper disable once HeuristicUnreachableCode
command2.Executed.Should().BeFalse(because: "Should undo as part of composite");
}
public void ShouldCallCanExecuteWithParameterWhenSettingCommand()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var parameter = new object();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
command.CanExecuteReturnValue = false;
behavior.CommandParameter = parameter;
Assert.IsNull(command.CanExecuteParameter);
Assert.IsTrue(clickableObject.IsEnabled);
behavior.Command = command;
Assert.IsNotNull(command.CanExecuteParameter);
Assert.AreSame(parameter, command.CanExecuteParameter);
Assert.IsFalse(clickableObject.IsEnabled);
}
public void DisposedControlDoesNotThrowOnCanExecuteChanged()
{
var clickableObject = new MockClickableObject();
var command = new MockCommand();
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = command;
WeakReference controlWeakReference = new WeakReference(clickableObject);
clickableObject = null;
behavior = null;
GC.Collect();
command.CanExecuteReturnValue = false;
command.RaiseCanExecuteChanged();
}
public void ExtractOptions_ReturnsEmptyCommandWhenCommandLineIsEmpty()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Message");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
var argsEnumerator = new List<string>().GetEnumerator();
// Act
ICommand actualCommand = parser.ExtractOptions(ExpectedCommand, argsEnumerator);
// Assert
Assert.Equal(0, actualCommand.Arguments.Count);
Assert.Null(((MockCommand)actualCommand).Message);
}
public void ShouldReEnableButtonIfCanExecuteChangedRaises()
{
var clickableObject = new MockClickableObject();
var mockCommand = new MockCommand()
{
CanExecuteReturnValue = false
};
var behavior = new ButtonBaseClickCommandBehavior(clickableObject);
behavior.Command = mockCommand;
Assert.IsFalse(clickableObject.IsEnabled);
mockCommand.CanExecuteReturnValue = true;
mockCommand.RaiseCanExecuteChanged();
Assert.IsTrue(clickableObject.IsEnabled);
}
public void ExtractOptions_AddsArgumentsWhenItemsDoNotStartWithSlashOrDash()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Message");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
var argsEnumerator = new List<string>() { "optionOne", "optionTwo" }.GetEnumerator();
// Act
ICommand actualCommand = parser.ExtractOptions(ExpectedCommand, argsEnumerator );
// Assert
Assert.AreEqual(2, actualCommand.Arguments.Count);
Assert.AreEqual("optionOne", actualCommand.Arguments[0]);
Assert.AreEqual("optionTwo", actualCommand.Arguments[1]);
Assert.IsNull(((MockCommand)actualCommand).Message);
}
public void GetCommandOptions_ReturnsCorrectOpionAttributeAndPropertyInfo()
{
// Arrange
CommandManager cm = new CommandManager();
ICommand cmd = new MockCommand();
cm.RegisterCommand(cmd);
Dictionary<OptionAttribute, PropertyInfo> expected = new Dictionary<OptionAttribute, PropertyInfo>();
var expectedOptionAttributeOne = new OptionAttribute("A Option");
var expectedPropertyInfoOne = typeof(MockCommand).GetProperty("Message");
expected.Add(expectedOptionAttributeOne, expectedPropertyInfoOne);
var expectedOptionAttributeTwo = new OptionAttribute("A Option Two");
var expectedPropertyInfoTwo = typeof(MockCommand).GetProperty("MessageTwo");
expected.Add(expectedOptionAttributeTwo, expectedPropertyInfoTwo);
// Act
IDictionary<OptionAttribute, PropertyInfo> actual = cm.GetCommandOptions(cmd);
// Assert
Assert.AreEqual(2, actual.Count);
Assert.AreEqual(expectedOptionAttributeOne, actual.Keys.First());
Assert.AreEqual(expectedPropertyInfoOne, actual[expectedOptionAttributeOne]);
Assert.AreEqual(expectedOptionAttributeTwo, actual.Keys.Last());
Assert.AreEqual(expectedPropertyInfoTwo, actual[expectedOptionAttributeTwo]);
}
public void ExtractOptions_ThrowsIfUnableToConvertType()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Count");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var command = new MockCommand();
string expectedErrorMessage = "Invalid option value: '/Count null'";
var argsEnumerator = new List<string>() { "/Count", "null" }.GetEnumerator();
// Act & Assert
ExceptionAssert.Throws<CommandLineException>(() => parser.ExtractOptions(command, argsEnumerator), expectedErrorMessage);
}
public void ExtractOptions_ParsesBoolOptionsAsFalseIfFollowedByDash()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("IsWorking");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
var argsEnumerator = new List<string>() { "-IsWorking-" }.GetEnumerator();
// Act
ICommand actualCommand = parser.ExtractOptions(ExpectedCommand, argsEnumerator);
// Assert
Assert.IsFalse(((MockCommand)actualCommand).IsWorking);
}
public void ExtractOptions_ThrowsWhenOptionHasNoValue()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Message");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
string expectedErrorMessage = "Missing option value for: '/Message'";
var argsEnumerator = new List<string>() { "/Message" }.GetEnumerator();
// Act & Assert
ExceptionAssert.Throws<CommandLineException>(() => parser.ExtractOptions(ExpectedCommand, argsEnumerator), expectedErrorMessage);
}
public void ExtractOptions_UsesShortenedForm()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Message");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
var argsEnumerator = new List<string>() { "/Mess", "foo bar" }.GetEnumerator();
// Act
ICommand actualCommand = parser.ExtractOptions(ExpectedCommand, argsEnumerator);
// Assert
Assert.AreEqual("foo bar", ((MockCommand)actualCommand).Message);
}
public void ExtractOptions_ThrowsIfCommandOptionIsAmbigious()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option 1");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Count");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
mockOptionAttribute = new OptionAttribute("Mock Option 2");
mockPropertyInfo = typeof(MockCommand).GetProperty("Counter");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
string expectedErrorMessage = "Ambiguous option 'Co'. Possible values: Count Counter.";
var argsEnumerator = new List<string>() { "/Co", "null" }.GetEnumerator();
// Act & Assert
ExceptionAssert.Throws<CommandLineException>(() => parser.ExtractOptions(ExpectedCommand, argsEnumerator), expectedErrorMessage);
}
public void ExtractOptions_ThrowsIfCommandOptionDoesNotExist()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option 1");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Count");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
mockOptionAttribute = new OptionAttribute("Mock Option 2");
mockPropertyInfo = typeof(MockCommand).GetProperty("Counter");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
string expectedErrorMessage = "Unknown option: '/37264752DOESNOTEXIST!!'";
var argsEnumerator = new List<string>() { "/37264752DOESNOTEXIST!!", "false" }.GetEnumerator();
// Act & Assert
ExceptionAssert.Throws<CommandLineException>(() => parser.ExtractOptions(ExpectedCommand, argsEnumerator), expectedErrorMessage);
}
public void ExtractOptions_ThrowsIfCommandHasNoProperties()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var ExpectedCommand = new MockCommand();
string expectedErrorMessage = "Unknown option: '/Count'";
var argsEnumerator = new List<string>() { "/Count", "null" }.GetEnumerator();
// Act & Assert
ExceptionAssert.Throws<CommandLineException>(() => parser.ExtractOptions(ExpectedCommand, argsEnumerator), expectedErrorMessage);
}
public void ExtractOptions_ParsesBoolOptionsAsTrueIfPresent()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("IsWorking");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var command = new MockCommand();
var argsEnumerator = new List<string>() { "-IsWorking" }.GetEnumerator();
// Act
parser.ExtractOptions(command, argsEnumerator);
// Assert
Assert.True(command.IsWorking);
}
public void ExtractOptions_ParsesOptionsThatStartWithDash()
{
// Arrange
var cmdMgr = new Mock<ICommandManager>();
var MockCommandOptions = new Dictionary<OptionAttribute, PropertyInfo>();
var mockOptionAttribute = new OptionAttribute("Mock Option");
var mockPropertyInfo = typeof(MockCommand).GetProperty("Message");
MockCommandOptions.Add(mockOptionAttribute, mockPropertyInfo);
cmdMgr.Setup(cm => cm.GetCommandOptions(It.IsAny<ICommand>())).Returns(MockCommandOptions);
CommandLineParser parser = new CommandLineParser(cmdMgr.Object);
var command = new MockCommand();
var argsEnumerator = new List<string>() { "-Message", "foo bar" }.GetEnumerator();
// Act
parser.ExtractOptions(command, argsEnumerator);
// Assert
Assert.Equal("foo bar", command.Message);
}
