public void Constructor_ReturnsCommandWithCanExecute_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
DelegateCommand command = new DelegateCommand(handler.Execute, handler.CanExecute);
Assert.IsNotNull(command);
}
public void Constructor_ReturnsCommandWithCanExecute_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>();
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
Assert.NotNull(command);
}
public void Constructor_ReturnsCommandWithCanExecute_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
DelegateCommand command = new DelegateCommand(handler.Execute, handler.CanExecute);
Assert.NotNull(command);
}
public void Constructor_ReturnsCommandWithCanExecute_GenericClass()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>();
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.NotNull(command);
}
public void Constructor_ReturnsCommandWithCanExecute_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>();
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
Assert.IsNotNull(command);
}
public void Constructor_ReturnsCommandWithCanExecute_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.IsNotNull(command);
}
public void Constructor_Exception_CanExecuteMethodIsNull_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
var e = Assert.Throws <ArgumentNullException>(() => new DelegateCommand(handler.Execute, null));
Assert.Equal("Value cannot be null.\r\nParameter name: canExecute", e.Message);
Assert.Equal("canExecute", e.ParamName);
}
public void CanExecute_PassesArgument_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>();
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
command.CanExecute(42);
Assert.Equal <int>(new[] { 42 }, handler.ArgumentList);
}
public async Task Should_add_participants_to_conference()
{
var result = await Controller.AddParticipantsToConferenceAsync(TestConference.Id, _request);
MockCommandHandler.Verify(c => c.Handle(It.IsAny <AddParticipantsToConferenceCommand>()), Times.Once);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public void CanExecute_ReturnsFalseIfNullParameter_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>()
{
CanExecuteValue = true
};
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
Assert.False(command.CanExecute(null));
}
public void CanExecute_WillReturnFalse_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>()
{
CanExecuteValue = false
};
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
Assert.False(command.CanExecute(42));
}
public void CanExecute_WillReturnFalse_GenericClass()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>()
{
CanExecuteValue = false
};
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.False(command.CanExecute(new MockArgumentClass()));
}
public void CanExecute_WillReturnTrue_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler()
{
CanExecuteValue = true
};
DelegateCommand command = new DelegateCommand(handler.Execute, handler.CanExecute);
Assert.True(command.CanExecute(new MockArgumentClass()));
}
public void CanExecute_PassesArgument_GenericClass()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>();
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
MockArgumentClass argument = new MockArgumentClass();
command.CanExecute(argument);
Assert.Equal <MockArgumentClass>(new[] { argument }, handler.ArgumentList);
}
public void CanExecute_ReturnsFalseIfIncorrectType_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>()
{
CanExecuteValue = true
};
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
Assert.False(command.CanExecute(new MockArgumentClass()));
}
public void CanExecute_ReturnsTrueIfNullParameter_GenericClass()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>()
{
CanExecuteValue = true
};
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.True(command.CanExecute(null));
}
public void Execute_CallsExecuteMethod_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
DelegateCommand command = new DelegateCommand(handler.Execute);
Assert.Equal(0, handler.ExecuteCallCount);
command.Execute(new MockArgumentClass());
Assert.Equal(1, handler.ExecuteCallCount);
}
public void CanExecute_CallsCanExecuteMethod_GenericClass()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>();
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.Equal(0, handler.CanExecuteCallCount);
command.CanExecute(new MockArgumentClass());
Assert.Equal(1, handler.CanExecuteCallCount);
}
public void CanExecute_CallsCanExecuteMethod_GenericStruct()
{
MockCommandHandler <int> handler = new MockCommandHandler <int>();
DelegateCommand <int> command = new DelegateCommand <int>(handler.Execute, handler.CanExecute);
Assert.Equal(0, handler.CanExecuteCallCount);
command.CanExecute(42);
Assert.Equal(1, handler.CanExecuteCallCount);
}
public async Task Should_remove_given_participants_from_conference()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
await Controller.RemoveParticipantFromConferenceAsync(conferenceId, participant.Id);
MockQueryHandler.Verify(m => m.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
MockCommandHandler.Verify(c =>
c.Handle(It.Is <RemoveParticipantsFromConferenceCommand>(x => x.Participants[0].Id == participant.Id)), Times.Once);
}
private (IEntity, CommandPacketHandler, MockCommandHandler) Data(string targetStr)
{
var c = new ServiceCollection();
var ch = new MockCommandHandler(targetStr);
c.AddSingleton <ICommandHandler>(_ => ch);
var s = Mock.Server(c);
var p = Mock.Player("a", s).Get();
return(p, new CommandPacketHandler(s.Services), ch);
}
public async Task Should_save_heartbeat()
{
var conferenceId = TestConference.Id;
var participantId = TestConference.GetParticipants()[1].Id;
var result = await Controller.SaveHeartbeatDataForParticipantAsync(conferenceId, participantId, new AddHeartbeatRequest());
MockCommandHandler.Verify(c => c.Handle(It.IsAny <SaveHeartbeatCommand>()), Times.Once);
result.Should().NotBeNull();
result.Should().BeAssignableTo <NoContentResult>();
}
public async Task Should_return_notfound_with_no_matching_conference()
{
MockCommandHandler
.Setup(
x => x.Handle(It.IsAny <AddParticipantsToConferenceCommand>()))
.ThrowsAsync(new ConferenceNotFoundException(TestConference.Id));
var result = await Controller.AddParticipantsToConferenceAsync(Guid.NewGuid(), _request);
var typedResult = (NotFoundResult)result;
typedResult.Should().NotBeNull();
}
public async Task Should_update_given_participants_details()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
var result = await Controller.UpdateParticipantDetailsAsync(conferenceId, participant.Id, _updateParticipantRequest);
MockCommandHandler.Verify(c => c.Handle(It.IsAny <UpdateParticipantDetailsCommand>()), Times.Once);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public async Task should_return_not_found()
{
MockVideoPlatformService
.Setup(x => x.GetTestCallScoreAsync(It.IsAny <Guid>(), It.IsAny <int>()))
.Returns(Task.FromResult <TestCallResult>(null));
var response = await Controller.GetTestCallResultForParticipantAsync(Guid.NewGuid(), Guid.NewGuid());
var typedResult = (NotFoundResult)response;
typedResult.Should().NotBeNull();
MockCommandHandler.Verify(x => x.Handle(It.IsAny <UpdateSelfTestCallResultCommand>()), Times.Never);
}
protected override void Register(AutoMockContainer container)
{
MockHandler = new MockCommandHandler();
container.Register <ICommandHandler>(MockHandler);
container.Register(new Config());
FeedCacheMock = container.GetMock <IFeedCache>();
CatalogManagerMock = container.GetMock <ICatalogManager>();
StoreMock = container.GetMock <IStore>();
PackageManagerMock = container.GetMock <IPackageManager>();
SolverMock = container.GetMock <ISolver>();
FetcherMock = container.GetMock <IFetcher>();
ExecutorMock = container.GetMock <IExecutor>();
}
public void NotifyCanExecuteChanged_FiresCanExecuteChangedEvent()
{
MockCommandHandler <MockArgumentClass> handler = new MockCommandHandler <MockArgumentClass>();
DelegateCommand <MockArgumentClass> command = new DelegateCommand <MockArgumentClass>(handler.Execute, handler.CanExecute);
int canExecuteChangedCount = 0;
command.CanExecuteChanged += (sender, e) =>
{
canExecuteChangedCount++;
};
command.NotifyCanExecuteChanged();
Assert.Equal(1, canExecuteChangedCount);
}
public async Task Should_return_notfound_with_no_matching_participant()
{
MockCommandHandler
.Setup(
x => x.Handle(It.IsAny <UpdateParticipantDetailsCommand>()))
.ThrowsAsync(new ParticipantNotFoundException(Guid.NewGuid()));
var result =
await Controller.UpdateParticipantDetailsAsync(TestConference.Id, Guid.NewGuid(),
_updateParticipantRequest);
var typedResult = (NotFoundResult)result;
typedResult.Should().NotBeNull();
}
public async Task should_add_username_to_command_when_provided()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
_updateParticipantRequest.Username = "******";
var result = await Controller.UpdateParticipantDetailsAsync(conferenceId, participant.Id, _updateParticipantRequest);
MockCommandHandler.Verify(c => c.Handle(It.Is <UpdateParticipantDetailsCommand>(c => c.Username == _updateParticipantRequest.Username)), Times.Once);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public async Task Should_Error_ForInvalidModelState()
{
var data = new AddWordPostModel
{
Word = "Bonjour",
Answers = new [] { "Hello", "Good Morning" }
};
var mockHandler = new MockCommandHandler <AddWordCommand>().ReturnsForAll().Handler;
var controller = new WordsController(mockHandler, null);
controller.ModelState.AddModelError(string.Empty, "Something is wrong!");
var result = await controller.AddWord(data);
result.Should().BeOfType <BadRequestObjectResult>();
}
public void CommandHandlerShouldBeResolved()
{
//Given
var commandHandlerFactory = new CommandHandlerFactory();
var mockCommandHandler = new MockCommandHandler(new List <string>());
var updateMockCommandHandler = new UpdateMockCommandHandler();
//When
commandHandlerFactory.Register <CreateAMockCommand>(mockCommandHandler);
commandHandlerFactory.Register <UpdateMockCommand>(updateMockCommandHandler);
var first_CommandHandler = commandHandlerFactory.Resolved <CreateAMockCommand>();
var second_commandHandler = commandHandlerFactory.Resolved <UpdateMockCommand>();
//Then
Assert.IsType <MockCommandHandler>(first_CommandHandler);
Assert.IsType <UpdateMockCommandHandler>(second_commandHandler);
}
public async Task Should_AddWord(string word, string[] answers)
{
var data = new AddWordPostModel
{
Word = word,
Answers = answers
};
var mockCommandHandler = new MockCommandHandler <AddWordCommand>().ReturnsForAll().Handler;
var mockQueryHandler = new MockQueryHandler <FindItemsQuery, LearningItem[]>()
.ReturnsForAll(new [] { new LearningItem(word, answers) })
.Handler;
var controller = new WordsController(mockCommandHandler, mockQueryHandler);
var result = await controller.AddWord(data);
result.Should().BeOfType <CreatedResult>();
var createdResult = (CreatedResult)result;
createdResult.StatusCode.Should().Be(201);
createdResult.Location.Should().MatchRegex(@"\/Words\/[{(]?[0-9A-Fa-f]{8}[-]?([0-9A-Fa-f]{4}[-]?){3}[0-9A-Fa-f]{12}[)}]?");
}
public async Task should_return_okay_with_response()
{
var testResult = Builder <TestCallResult> .CreateNew()
.WithFactory(() => new TestCallResult(true, TestScore.Good)).Build();
MockVideoPlatformService
.Setup(x => x.GetTestCallScoreAsync(It.IsAny <Guid>(), It.IsAny <int>()))
.Returns(Task.FromResult(testResult));
var conferenceId = Guid.NewGuid();
var participantId = Guid.NewGuid();
var command =
new UpdateSelfTestCallResultCommand(conferenceId, participantId, testResult.Passed, testResult.Score);
MockCommandHandler.Setup(x => x.Handle(command));
var response = await Controller.GetTestCallResultForParticipantAsync(Guid.NewGuid(), Guid.NewGuid());
var typedResult = (OkObjectResult)response;
typedResult.Should().NotBeNull();
}
public void CanExecute_PassesArgument_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
MockArgumentClass argument = new MockArgumentClass();
command.CanExecute(argument);
CollectionAssert.AreEqual(new[] { argument }, (ICollection)handler.ArgumentList);
}
public void NotifyCanExecuteChanged_FiresCanExecuteChangedEvent()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
int canExecuteChangedCount = 0;
command.CanExecuteChanged += (sender, e) =>
{
canExecuteChangedCount++;
};
command.NotifyCanExecuteChanged();
Assert.AreEqual(1, canExecuteChangedCount);
}
public void CanExecute_WillReturnTrue_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler() { CanExecuteValue = true };
DelegateCommand command = new DelegateCommand(handler.Execute, handler.CanExecute);
Assert.IsTrue(command.CanExecute(new MockArgumentClass()));
}
public void CanExecute_PassesArgument_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>();
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
command.CanExecute(42);
CollectionAssert.AreEqual(new[] { 42 }, (ICollection)handler.ArgumentList);
}
public void Constructor_Exception_CanExecuteMethodIsNull_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
Assert.ThrowsException<ArgumentNullException>(() => new DelegateCommand(handler.Execute, null));
}
public void Constructor_Exception_CanExecuteMethodIsNull_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
Assert.ThrowsException<ArgumentNullException>(() => new DelegateCommand<MockArgumentClass>(handler.Execute, null));
}
public void Execute_PassesArgument_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute);
MockArgumentClass argument = new MockArgumentClass();
command.Execute(argument);
Assert.Equal<MockArgumentClass>(new[] { argument }, handler.ArgumentList);
}
public void Constructor_Exception_CanExecuteMethodIsNull_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
var e = Assert.Throws<ArgumentNullException>(() => new DelegateCommand(handler.Execute, null));
Assert.Equal("Value cannot be null.\r\nParameter name: canExecute", e.Message);
Assert.Equal("canExecute", e.ParamName);
}
public void Execute_PassesArgument_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>();
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute);
command.Execute(42);
Assert.Equal<int>(new[] { 42 }, handler.ArgumentList);
}
public void CanExecute_CallsCanExecuteMethod_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>();
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
Assert.AreEqual(0, handler.CanExecuteCallCount);
command.CanExecute(42);
Assert.AreEqual(1, handler.CanExecuteCallCount);
}
public void CanExecute_ReturnsFalseIfNullParameter_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = true };
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
Assert.IsFalse(command.CanExecute(null));
}
public void CanExecute_ReturnsTrueIfNullParameter_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>() { CanExecuteValue = true };
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.IsTrue(command.CanExecute(null));
}
public void CanExecute_ReturnsFalseIfIncorrectType_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = true };
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
Assert.IsFalse(command.CanExecute(new MockArgumentClass()));
}
public void CanExecute_WillReturnFalse_GenericStruct()
{
MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = false };
DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);
Assert.IsFalse(command.CanExecute(42));
}
public void CanExecute_WillReturnFalse_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>() { CanExecuteValue = false };
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.IsFalse(command.CanExecute(new MockArgumentClass()));
}
public void Execute_CallsExecuteMethod_NonGeneric()
{
MockCommandHandler handler = new MockCommandHandler();
DelegateCommand command = new DelegateCommand(handler.Execute);
Assert.AreEqual(0, handler.ExecuteCallCount);
command.Execute(new MockArgumentClass());
Assert.AreEqual(1, handler.ExecuteCallCount);
}
public void CanExecute_CallsCanExecuteMethod_GenericClass()
{
MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
Assert.AreEqual(0, handler.CanExecuteCallCount);
command.CanExecute(new MockArgumentClass());
Assert.AreEqual(1, handler.CanExecuteCallCount);
}
