public IActionResult Add(AddCourseCommand command)
{
var result = _mediator.Command(command);
if (result.IsFailure)
{
ModelState.PopulateValidation(result.Errors);
return(View(command));
}
return(RedirectToAction("Index"));
}
public IActionResult Create([FromBody] AddCourseCommand command)
{
var validationResult = this.addCourseCommandValidator.PerformValidation(command);
if (validationResult.IsValid)
{
this.bus.SendUsingMedia(command);
return(this.Ok());
}
else
{
return(this.BadRequest(validationResult));
}
}
public void ExecuteShouldRetrurnMessageWhenUserNotLogged()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
state.Setup(s => s.IsLogged).Returns(false);
var parameters = new string[] { "Username", "1" };
//Assert + Act
Assert.AreEqual("You will need to login first", command.Execute(parameters));
}
public void ExecuteShouldReturnWhenCourseIsNull()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
state.Setup(s => s.IsLogged).Returns(true);
state.Setup(s => s.RoleId).Returns(2);
var parameters = new string[] { "" };
//Assert + Act
Assert.AreEqual("The course name can`t be null", command.Execute(parameters));
}
public void ExecuteShouldReturnWhenIncorrectRoleIsPassed()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
state.Setup(s => s.IsLogged).Returns(true);
state.Setup(s => s.RoleId).Returns(3);
var parameters = new string[] { "Username" };
//Assert + Act
Assert.AreEqual("This command is available only to users with role Teacher", command.Execute(parameters));
}
public void AddCourse_WhenItIsPossible_ShouldSuccess()
{
using (var sut = new SystemUnderTest())
{
var command = new AddCourseCommand
{
Name = "Kurs Angielskiego A1",
Year = 2019,
TrainingTime = 350
};
var unitOfWorkSubstitute = Substitute.For <IUnitOfWork>();
var handler = new AddCourseCommandHandler(unitOfWorkSubstitute);
var result = handler.Handle(command);
result.IsSuccess.Should().Be(true);
}
}
public void ExecuteShouldThrowWhenDateTimeIsIncorrect()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
state.Setup(s => s.IsLogged).Returns(true);
state.Setup(s => s.RoleId).Returns(2);
var parameters = new string[] { "Alpha_JS", "pesho", "pesho" };
//Assert + Act
var result = command.Execute(parameters);
Assert.AreEqual("Please enter valid DateTime", result);
}
public void ExecuteShouldCallServiceMethodAddCourseOnce()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
state.Setup(s => s.IsLogged).Returns(true);
state.Setup(s => s.RoleId).Returns(2);
state.SetupGet(s => s.UserName).Returns("pesho");
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
var parameters = new string[] { "06-22-2012", "06-22-2013", "Alpha JS" };
command.Execute((parameters));
service.Verify(s => s.AddCourse("pesho", DateTime.Parse("06 - 22 - 2012"), DateTime.Parse("06-22-2013"), "Alpha JS"), Times.Once);
}
public async Task <ActionResult> Create(AddCourseCommand addCourseCommand)
{
var ok = false;
using (var httpClient = new HttpClient())
{
string json = JsonConvert.SerializeObject(addCourseCommand);
HttpContent content = new StringContent(json, System.Text.Encoding.UTF8,
"application/json");
Console.WriteLine("json " + json);
using var response = await httpClient.PostAsync(_configuration.GetSection ("apiUrl").Value + "/courses/Add", content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
if (response.StatusCode == HttpStatusCode.OK)
{
ok = true;
}
}
return(RedirectToAction(""));
}
public void AddCourse_WhenExist_ShouldFail()
{
using (var sut = new SystemUnderTest())
{
var command = new AddCourseCommand
{
Name = "Kurs Angielskiego A1",
Year = 2019,
TrainingTime = 350
};
var unitOfWorkSubstitute = Substitute.For <IUnitOfWork>();
unitOfWorkSubstitute.CoursesRepository
.IsCourseExist(command.Name, command.Year)
.Returns(true);
var handler = new AddCourseCommandHandler(unitOfWorkSubstitute);
var result = handler.Handle(command);
result.IsFailure.Should().Be(true);
}
}
public void ExecuteShouldCatchUserAlreadyExistsException()
{
//Arrange
var state = new Mock <ISessionState>();
var builder = new Mock <IStringBuilderWrapper>();
var service = new Mock <ICourseService>();
state.Setup(s => s.IsLogged).Returns(true);
state.Setup(s => s.RoleId).Returns(2);
state.SetupGet(s => s.UserName).Returns("pesho");
service.Setup(s =>
s.AddCourse("pesho", DateTime.Parse("06-22-2012"), DateTime.Parse("06-22-2013"), "Alpha JS"))
.Throws(new EntityAlreadyExistsException("Course already exists"));
var command = new AddCourseCommand(state.Object, builder.Object, service.Object);
var parameters = new string[] { "06-22-2012", "06-22-2013", "Alpha JS" };
var str = command.Execute(parameters);
Assert.AreEqual("Course already exists", str);
}
public async Task <IActionResult> Add(AddCourseCommand command)
{
int id = await Mediator.Send(command);
return(Ok(id));
}
public async Task <IActionResult> AddCourse(AddCourseCommand command)
{
return(Ok(await mediator.Send(command)));
}
// GET: Courses/Create
public ActionResult Create()
{
AddCourseCommand course = new AddCourseCommand();
return(View(course));
}
public async Task <ActionResult <PagenatedList <CourseDto> > > AddCourse([FromBody] AddCourseCommand cmd)
{
return(Ok(await _mediator.Send(cmd)));
}
