public async Task Given_An_Valid_Deck_Create_Command_Should_Be_Successful()
{
// Arrange
var deck = new DeckInputModel
{
Name = "deck tester",
UserId = Guid.NewGuid().ToString(),
MainDeck = new List <CardInputModel>()
};
_fixture.RepeatCount = 40;
deck.MainDeck =
_fixture
.Build <CardInputModel>()
.With(c => c.BaseType, "monster")
.Without(c => c.Types)
.CreateMany()
.ToList();
var command = new CreateDeckCommand {
Deck = deck
};
_deckService.Add(Arg.Any <DeckModel>()).Returns(new Deck {
Id = 23424 /*new deck id*/
});
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.IsSuccessful.Should().BeTrue();
}
public async Task Put_WhenCalled_With_An_Valid_Deck_But_Fails_Validation_Rules_Should_Return_BadRequestObjectResult()
{
// Arrange
const string expected = "40 cards minimum";
var deck = new DeckInputModel {
Name = "Test Deck"
};
_userManager.GetUserAsync(Arg.Any <ClaimsPrincipal>()).Returns(new ApplicationUser {
Id = Guid.NewGuid().ToString()
});
_mediator.Send(Arg.Any <IRequest <CommandResult> >()).Returns(new CommandResult {
Errors = new List <string> {
"40 cards minimum"
}
});
// Act
var result = await _sut.Put(deck) as BadRequestObjectResult;
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
var errors = result?.Value as IEnumerable <string>;
errors.Should().ContainSingle(expected);
}
[RequestSizeLimit(100_000_00)] // 10MB request size
public async Task <IActionResult> Post([FromBody] DeckInputModel newDeck)
{
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
if (user != null)
{
newDeck.UserId = user.Id;
var command = new CreateDeckCommand
{
Deck = newDeck
};
var result = await _mediator.Send(command);
if (result.IsSuccessful)
{
return(CreatedAtRoute("GetDeckById", new { id = result.Data }, result.Data));
}
return(BadRequest(result.Errors));
}
}
else
{
return(BadRequest(ModelState.Errors()));
}
return(BadRequest());
}
[RequestSizeLimit(100_000_00)] // 10MB request size
public async Task <IActionResult> Put([FromBody] DeckInputModel updateDeck)
{
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
if (user != null)
{
updateDeck.UserId = user.Id;
var command = new UpdateDeckCommand
{
Deck = updateDeck
};
var result = await _mediator.Send(command);
if (result.IsSuccessful)
{
return(Ok(result.Data));
}
return(BadRequest(result.Errors));
}
}
else
{
return(BadRequest(ModelState.Errors()));
}
return(BadRequest());
}
public async Task Put_WhenCalled_With_A_Valid_Deck_And_Authenticated_User_Is_Not_Found_Should_Return_BadRequestResult()
{
// Arrange
var deck = new DeckInputModel {
Name = "Test Deck"
};
_userManager.GetUserAsync(Arg.Any <ClaimsPrincipal>()).Returns((ApplicationUser)null);
// Act
var result = await _sut.Put(deck) as BadRequestResult;
// Assert
result.Should().BeOfType <BadRequestResult>();
}
public async Task Post_WhenCalled_With_An_Invalid_Deck_Should_Return_BadRequestObjectResult()
{
// Arrange
const string expected = "Name is required";
var deck = new DeckInputModel();
_sut.ModelState.AddModelError("Name", "Name is required");
// Act
var result = await _sut.Post(deck) as BadRequestObjectResult;
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
var errors = result?.Value as IEnumerable <string>;
errors.Should().ContainSingle(expected);
}
public async Task Given_An_Invalid_Deck_Create_Command_Should_Return_A_List_Of_Errors()
{
// Arrange
var deck = new DeckInputModel
{
MainDeck = new List <CardInputModel>()
};
var command = new CreateDeckCommand {
Deck = deck
};
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.Errors.Should().NotBeEmpty();
}
public async Task Given_An_Invalid_Deck_Create_Command_Should_Not_Be_Successful()
{
// Arrange
var deck = new DeckInputModel
{
MainDeck = new List <CardInputModel>()
};
var command = new CreateDeckCommand {
Deck = deck
};
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.IsSuccessful.Should().BeFalse();
}
public async Task <IActionResult> CreateDeck(DeckInputModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(inputModel));
}
var user = await this.userManager.GetUserAsync(this.User);
var thumbnailUrl = string.Empty;
if (inputModel.Thumbnail != null)
{
thumbnailUrl = this.coursesService.UploadImageToCloudinary(inputModel.Thumbnail.OpenReadStream());
}
var deck = await this.decksService.CreateDeck(inputModel.Name, inputModel.IsPublic, user.Id, thumbnailUrl);
return(this.RedirectToAction("CreateCard", "Cards", new { deckId = deck.Id }));
}
public async Task Given_A_Deck_If_User_Is_Not_Owner_Should_Return_Errors()
{
// Arrange
var deck = new DeckInputModel
{
MainDeck = new List <CardInputModel>()
};
var command = new DeleteDeckCommand {
Deck = deck
};
_userService.IsUserDeckOwner(Arg.Any <string>(), Arg.Any <long>()).Returns(false);
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.Errors.Should().NotBeEmpty();
}
public async Task Given_A_Deck_If_User_Is_Not_Owner_Should_Not_Invoke_DeleteDeckByIdAndUserId()
{
// Arrange
var deck = new DeckInputModel
{
MainDeck = new List <CardInputModel>()
};
var command = new DeleteDeckCommand {
Deck = deck
};
_userService.IsUserDeckOwner(Arg.Any <string>(), Arg.Any <long>()).Returns(false);
// Act
await _sut.Handle(command, CancellationToken.None);
// Assert
await _deckService.DidNotReceive().DeleteDeckByIdAndUserId(Arg.Any <string>(), Arg.Any <long>());
}
public async Task Put_WhenCalled_With_A_Valid_Deck_If_Deck_Is_Created_Should_Return_CreatedAtRouteResult()
{
// Arrange
var deck = new DeckInputModel {
Name = "Test Deck"
};
_userManager.GetUserAsync(Arg.Any <ClaimsPrincipal>()).Returns(new ApplicationUser {
Id = Guid.NewGuid().ToString()
});
_mediator.Send(Arg.Any <IRequest <CommandResult> >()).Returns(new CommandResult {
IsSuccessful = true, Data = 2342
});
// Act
var result = await _sut.Put(deck) as OkObjectResult;
// Assert
result.Should().BeOfType <OkObjectResult>();
}
public async Task Given_An_Valid_Deck_Create_Command_Should_Be_Successful_And_New_DeckId_Returned()
{
// Arrange
const int expected = 23424;
var deck = new DeckInputModel
{
Name = "deck tester",
UserId = Guid.NewGuid().ToString(),
MainDeck = new List <CardInputModel>()
};
_fixture.RepeatCount = 40;
deck.MainDeck =
_fixture
.Build <CardInputModel>()
.With(c => c.BaseType, "monster")
.Without(c => c.Types)
.CreateMany()
.ToList();
var command = new CreateDeckCommand {
Deck = deck
};
_deckService.Add(Arg.Any <DeckModel>()).Returns(new Deck {
Id = 23424 /*new deck id*/
});
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
dynamic dyn = result.Data;
int newDeckId = int.Parse(dyn.GetType().GetProperty("deckId").GetValue(dyn, null).ToString());
newDeckId.Should().Be(expected);
}
public async Task Given_An_Valid_Deck_If_User_Is_Not_Owner_Update_Command_Should_Fail()
{
// Arrange
var deck = new DeckInputModel
{
Id = 3242,
Name = "deck tester",
UserId = Guid.NewGuid().ToString(),
MainDeck = new List <CardInputModel>()
};
_fixture.RepeatCount = 40;
deck.MainDeck =
_fixture
.Build <CardInputModel>()
.With(c => c.BaseType, "monster")
.Without(c => c.Types)
.CreateMany()
.ToList();
var command = new UpdateDeckCommand {
Deck = deck
};
_userService.IsUserDeckOwner(Arg.Any <string>(), Arg.Any <long>()).Returns(false);
_deckService.Update(Arg.Any <DeckModel>()).Returns(new Deck {
Id = 23424 /*new deck id*/
});
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.IsSuccessful.Should().BeFalse();
}
public void SetUp()
{
_sut = new DeckNameValidator();
_inputModel = new DeckInputModel();
}
public void SetUp()
{
_sut = new DeckValidator();
_inputModel = new DeckInputModel();
_fixture = new Fixture();
}
public void SetUp()
{
_sut = new YoutubeUrlValidator();
_inputModel = new DeckInputModel();
}
