public async Task GetAllAsync_Should_Return_OkObjectResult_With_a_List_of_IssueDtos_Test()
{
// Arrange
var expectedIssues = new List <IssueDto>()
{
new IssueDto()
{
Id = 1, IssueDescription = "Test 1", DateAdded = DateTimeOffset.Now
},
new IssueDto()
{
Id = 2, IssueDescription = "Test 2", DateAdded = DateTimeOffset.Now
},
new IssueDto()
{
Id = 3, IssueDescription = "Test 3", DateAdded = DateTimeOffset.Now
}
};
IssueServiceMock
.Setup(x => x.GetAllIssuesAsync())
.ReturnsAsync(expectedIssues);
// Act
var result = await ControllerUnderTest.GetAllIssuesAsync();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedIssues, okResult.Value);
}
public async void Should_return_ok()
{
// Arrange
var book = new Book
{
Title = "The Hobbit",
Author = TestAuthorOne,
Genre = TestGenreTwo,
Rating = 6.6,
YearPublished = new DateTime(1939, 1, 1),
DateRead = DateTime.Now
};
var result = new Result();
result.Errors.Add("there was an error");
BasicBookServiceMock
.Setup(x => x.DeleteBookAsync(book.BookId))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.DeleteBook(book.BookId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Same(result, okResult.Value);
}
public async void ShouldReturnOKObjectResultWithClan()
{
//Arrange
var expectedClans = new Clan[]
{
new Clan {
Name = "Test Clan 1"
},
new Clan {
Name = "Test Clan 2"
},
new Clan {
Name = "Test Clan 3"
}
};
ClanServiceMock
.Setup(x => x.ReadAllAsync())
.ReturnsAsync(expectedClans);
//Act
var result = await ControllerUnderTest.ReadAllAsync();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedClans, okResult.Value);
}
public async void Should_return_result_with_error()
{
// Arrange
var book = new Book
{
Title = "Dune",
Author = TestAuthorTwo,
Genre = TestGenreTwo,
Rating = 7.7,
YearPublished = new DateTime(1908, 1, 1),
DateRead = DateTime.Today
};
var result = new Result <Book>();
result.Errors.Add("there was an error");
BasicBookServiceMock
.Setup(x => x.GetBookAsync(book.BookId))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.GetBook(book.BookId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Same(result, okResult.Value);
}
public async void Should_return_result_with_error_message()
{
// Arrange
var book = new Book
{
Title = "Pachinko",
Author = TestAuthorOne,
Genre = TestGenreTwo,
Rating = 4.4,
YearPublished = new DateTime(1919, 1, 1),
DateRead = DateTime.Now
};
var result = new Result();
result.Errors.Add("an error happened");
BasicBookServiceMock
.Setup(x => x.AddBookAsync(book))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.AddBook(book);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Equal(result, okResult.Value);
}
public void Should_return_result_with_error()
{
// Arrange
var genres = new List <Genre>
{
new Genre
{
Name = "Horror"
},
new Genre
{
Name = "Fantasy"
}
};
var result = new Result <IList <Genre> >();
result.AddError("there was an error");
GenreServiceMock
.Setup(x => x.ListAllGenresAsync())
.ReturnsAsync(result);
// Act
var requestResult = ControllerUnderTest.ListAllGenres();
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult.Result);
Assert.Same(result, okResult.Value);
}
public async void Should_return_OkObjectResult_with_all_Ninja_in_Clan()
{
// Arrange
var clanName = "Some clan name";
var expectedNinjas = new Ninja[]
{
new Ninja {
Name = "Test Ninja 1"
},
new Ninja {
Name = "Test Ninja 2"
},
new Ninja {
Name = "Test Ninja 3"
}
};
NinjaServiceMock
.Setup(x => x.ReadAllInClanAsync(clanName))
.ReturnsAsync(expectedNinjas);
// Act
var result = await ControllerUnderTest.ReadAllInClanAsync(clanName);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedNinjas, okResult.Value);
}
public async void Should_return_NoContent_when_a_addressId_is_Invalid()
{
// Arrange
var userId = 1;
var unExistingAddressId = 55;
Address address = null;
AddressServiceMock
.Setup(x => x.ReadOneAsync(userId, unExistingAddressId)).ReturnsAsync(address);
var key = "Address_StatusCode_404_NotFound";
var localizedString = new LocalizedString(key, "Not Found");
LocalizerMock
.Setup(_ => _[key])
.Returns(localizedString);
// Act
var result = await ControllerUnderTest.GetUserAddress(userId, unExistingAddressId);
// Assert
Assert.IsType <NotFoundObjectResult>(result);
}
public async void Should_return_CreatedResult_when_model_Is_valid()
{
// Arrange
var returnExistValue = true;
var address = AddressData;
int userId = 1;
var resultObject = new Address
{
Address1 = "1601 Hood Avenue",
Address2 = "dolore in adipisicing et",
City = "San Diego",
CountryCode = "11",
PinCode = "92103",
StateId = 1
};
AddressServiceMock
.Setup(x => x.CreateAsync(userId, address))
.ReturnsAsync(resultObject);
UserServiceMock
.Setup(x => x.IsExistAsync(userId))
.ReturnsAsync(true);
//Act
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
var result = await ControllerUnderTest.CreateAddress(userId, address);
//Assert
var okResult = Assert.IsType <CreatedResult>(result);
Assert.Same(resultObject, okResult.Value);
}
public async void Should_return_error_with_message()
{
// Arrange
var authorDoesNotExist = new Author
{
Name = "Schrödinger's Cat",
Nationality = new Nationality {
Name = "Austria"
}
};
var result = new Result();
result.AddError("there was an error");
AuthorServiceMock
.Setup(x => x.UpdateAuthorAsync(authorDoesNotExist))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.UpdateAuthor(authorDoesNotExist);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Same(result, okResult.Value);
}
public void Should_return_result_with_error()
{
// Arrange
var authors = new List <AuthorListItem>
{
new AuthorListItem
{
Name = "Peter Piper",
Nationality = "Austrian"
},
new AuthorListItem
{
Name = "Spiderman",
Nationality = "American"
}
};
var result = new Result <IList <AuthorListItem> >();
result.AddError("there was an error");
AuthorServiceMock
.Setup(x => x.ListAllAuthorsAsync())
.ReturnsAsync(result);
// Act
var requestResult = ControllerUnderTest.ListAllAuthors();
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult.Result);
Assert.Same(result, okResult.Value);
}
public async void Should_return_error_with_message()
{
// Arrange
var duplicateAuthor = new Author
{
Name = "Katherine Man",
Nationality = new Nationality {
Name = "Mountains"
}
};
var result = new Result();
result.AddError("there was an error");
AuthorServiceMock
.Setup(x => x.AddAuthorAsync(duplicateAuthor))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.AddAuthor(duplicateAuthor);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Same(result, okResult.Value);
}
public async Task GetAllIssues_With_An_Exception_Should_Return_StatusCode_500_Test()
{
// Arrange
const string expectedLog = "Something went wrong inside GetAllIssuesAsync action: Some Error";
const string expectedValue = "Internal server error";
IssueServiceMock
.Setup(x => x.GetAllIssuesAsync())
.ThrowsAsync(new Exception("Some Error"));
// Act
var result = await ControllerUnderTest.GetAllIssuesAsync();
// Assert
result.Should().BeOfType <ObjectResult>();
LoggerMock.Invocations.Count.Should().Be(1);
LoggerMock.Invocations[0].Arguments[2].ToString().Should().Contain(expectedLog);
var content = (ObjectResult)result;
content.StatusCode.Should().Be(500);
content.Value.Should().Be(expectedValue);
}
public async Task DeleteIssueAsync_With_An_Exception_Should_Return_StatusCode_500_Test()
{
// Arrange
var expectedIssue = new IssueForDeleteDto
{
Id = 1, IssueDescription = "Test 1",
};
const string expectedLog = "Something went wrong inside DeleteIssueAsync action: Some Error";
const string expectedValue = "Internal server error";
IssueServiceMock
.Setup(x => x.DeleteIssueAsync(It.IsAny <IssueForDeleteDto>()))
.ThrowsAsync(new Exception("Some Error"));
// Act
var result = await ControllerUnderTest.DeleteIssueAsync(expectedIssue);
// Assert
result.Should().BeOfType <ObjectResult>();
LoggerMock.Invocations.Count.Should().Be(1);
LoggerMock.Invocations[0].Arguments[2].ToString().Should().Contain(expectedLog);
var content = (ObjectResult)result;
content.StatusCode.Should().Be(500);
content.Value.Should().Be(expectedValue);
}
public async Task Deve_Consultar_Por_Cnpj()
{
// Arrange
var listaTransicao = new List <Transacao>();
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179"
});
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179"
});
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179"
});
transacaoServiceMock
.Setup(x => x.ConsultaPorCnpj("77404852000179"))
.ReturnsAsync(listaTransicao);
// Act
var result = await ControllerUnderTest.ConsultaPorCnpj("77404852000179");
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(listaTransicao, okResult.Value);
}
public async void Should_return_OkObjectResult_with_topics()
{
// Arrange
var expectedTopics = new Topic[]
{
new Topic {
Id = 1, Title = "Titulo 1", Description = "Descrição 1", UserId = "1", CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now
},
new Topic {
Id = 2, Title = "Titulo 2", Description = "Descrição 2", UserId = "2", CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now
},
new Topic {
Id = 3, Title = "Titulo 3", Description = "Descrição 3", UserId = "3", CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now
}
};
TopicServiceMock
.Setup(x => x.GetAllAsync())
.ReturnsAsync(expectedTopics); // Mocked the GetAllAsync() result
// Act
var result = await ControllerUnderTest.GetAllAsync();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedTopics, okResult.Value);
}
public async Task Deve_Consultar_Por_Cnpj_e_bandeira()
{
// Arrange
var listaTransicao = new List <Transacao>();
listaTransicao.Add(new Transacao
{
MerchantCnpj = "77404852000179",
AcquirerAuthorizationDateTime = DateTime.Now,
CardBrandName = Const.Mastercard
});
transacaoServiceMock
.Setup(x => x.ConsultaPorCnpjEBandeira("77404852000179", Const.Mastercard))
.ReturnsAsync(listaTransicao);
// Act
var result = await ControllerUnderTest.ConsultaPorCnpjEBandeira("77404852000179", Const.Mastercard);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(listaTransicao, okResult.Value);
}
public async void GetVehiclesByStatus()
{
// Arrange
var expectedVehicles = new Page <Vehicle>
{
Items = new Vehicle[] {
new Vehicle {
Id = 1, CustomerId = 1, VIN = "111", RegNo = "1111111", IsActive = true
},
new Vehicle {
Id = 4, CustomerId = 2, VIN = "444", RegNo = "4444444", IsActive = true
},
new Vehicle {
Id = 5, CustomerId = 3, VIN = "555", RegNo = "5555555", IsActive = true
}
},
TotalSize = 3
};
VehiclesServiceMock
.Setup(x => x.GetByStatus(SearchVehicleStatus.Active, pagingOptions))
.ReturnsAsync(expectedVehicles);
// Act
var result = await ControllerUnderTest.GetByStatus(SearchVehicleStatus.Active, pagingOptions);
// Assert
Assert.Same(expectedVehicles, result);
}
public void Should_return_result_with_error()
{
// Arrange
var nationalities = new List <Nationality>
{
new Nationality
{
Name = "English",
},
new Nationality
{
Name = "Irish"
}
};
var result = new Result <IList <Nationality> >();
result.AddError("there was an error");
NationalityServiceMock
.Setup(x => x.ListAllNationalitiesAsync())
.ReturnsAsync(result);
// Act
var requestResult = ControllerUnderTest.ListAllNationalities();
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult.Result);
Assert.Same(result, okResult.Value);
}
public void When_Story_Controller_Index_retuns_success()
{
var result = ControllerUnderTest.Index();
// Assert
Assert.IsNotNull(result);
}
public async void Should_return_ok_with_book()
{
// Arrange
var book = new Book
{
Title = "The Prisoner of Azkaban",
Author = TestAuthorOne,
Genre = TestGenreOne,
Rating = 8.8,
YearPublished = new DateTime(1999, 1, 1),
DateRead = DateTime.Today
};
var result = new Result <Book>(book);
BasicBookServiceMock
.Setup(x => x.GetBookAsync(book.BookId))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.GetBook(book.BookId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Same(result, okResult.Value);
}
public async void Should_return_NotFound_when_phone_is_Invalid()
{
// Arrange
var invalidUserId = 0;
var expirationDays = "2";
string key = "User_StatusCode_404_NotFound";
var localizedString = new LocalizedString(key, "Not Found");
Contacts contact = new Contacts()
{
Phone = new Phone
{
CountryCode = "123",
Number = "7894561230"
}
};
ContactServiceMock.Setup(x => x.CheckValidUserByPhoneAsync(contact.Phone))
.ReturnsAsync(invalidUserId);
ConfigurationMock.Setup(x => x["PasswordConfig:OTPExpiryTime"])
.Returns(expirationDays);
LocalizerMock
.Setup(_ => _[key]).Returns(localizedString);
// Act
var result = await ControllerUnderTest.ForgotPassword(contact);
Assert.IsType <NotFoundObjectResult>(result);
}
public async void Should_return_ok_with_book()
{
// Arrange
var book = new Book
{
Title = "The Bible",
Author = TestAuthorOne,
Genre = TestGenreOne,
Rating = 0,
YearPublished = new DateTime(1, 1, 1),
DateRead = DateTime.Today
};
var result = new Result();
BasicBookServiceMock
.Setup(x => x.AddBookAsync(book))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.AddBook(book);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Equal((int)HttpStatusCode.OK, okResult.StatusCode);
Assert.Equal(result, okResult.Value);
}
public ActionResult TestName()
{
DeleteEntireHardDrive();
return(ControllerUnderTest.SaveName(new Person {
Name = "Henrik"
}));
}
public async void Should_return_ok()
{
// Arrange
var bookDto = new BookDto
{
Title = "The Wind in the Willows",
Rating = 5.8,
YearPublished = new DateTime(1970, 1, 1),
YearRead = DateTime.Now
};
var book = new Book
{
Title = "The Wind in the Willows",
Rating = 5.8,
YearPublished = new DateTime(1970, 1, 1),
DateRead = DateTime.Now
};
var toUpdate = MapperMock
.Setup(x => x.Map <Book>(bookDto))
.Returns(book);
var result = new Result();
BasicBookServiceMock
.Setup(x => x.UpdateBookAsync(book))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.UpdateBook(bookDto);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Equal((int)HttpStatusCode.OK, okResult.StatusCode);
Assert.Equal(result, okResult.Value);
}
public async void Should_return_OkObjectResult_with_clans()
{
// Arrange
var expectedPedidos = new Pedido[] {
new Pedido {
Id = new Guid(), DataCriacao = DateTime.Now
},
new Pedido {
Id = new Guid(), DataCriacao = DateTime.Now
},
new Pedido {
Id = new Guid(), DataCriacao = DateTime.Now
}
};
PedidoServiceMock
.Setup(x => x.ReadAllAsync())
.ReturnsAsync(expectedPedidos); // Mocked the ReadAllAsync() method
// Act
var result = await ControllerUnderTest.ReadAllAsync();
// Assert
var okResult = Assert.IsType <OkObjectResult> (result);
Assert.Same(expectedPedidos, okResult.Value);
}
public async Task Should_return_OkObjectResult_with_users()
{
//Arrange
var expectedUsers = new User[]
{
new User {
Name = "Gabriel Meyer", Email = "*****@*****.**"
},
new User {
Name = "Renato Rezende", Email = "*****@*****.**"
}
};
UserServiceMock
.Setup(x => x.GetAllAsync())
.ReturnsAsync(expectedUsers);
//Act
var result = await ControllerUnderTest.GetAllAsync();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedUsers, okResult.Value);
}
public async Task Deve_Consultar_Por_Bandeira()
{
// Arrange
var listaTransicao = new List <Transacao>();
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179", AcquirerName = "Cielo", CardBrandName = "MasterCard"
});
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179", AcquirerName = "Cielo", CardBrandName = "MasterCard"
});
listaTransicao.Add(new Transacao {
MerchantCnpj = "77404852000179", AcquirerName = "Cielo", CardBrandName = "MasterCard"
});
transacaoServiceMock
.Setup(x => x.ConsultaPorBandeira("Mastercard"))
.ReturnsAsync(listaTransicao);
// Act
var result = await ControllerUnderTest.ConsultaPorBandeira("Mastercard");
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(listaTransicao, okResult.Value);
}
public async void Should_return_BadRequest_when_model_is_null()
{
//Arrange
UserUpdate user = null;
var userId = 1;
var returnExistValue = true;
var key = "Me_StatusCode_400_BadRequest";
var localizedString = new LocalizedString(key, "Bad Request");
LocalizerMock
.Setup(_ => _[key])
.Returns(localizedString);
// Service
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
// set header values
ControllerUnderTest.ControllerContext.HttpContext.Request.Headers.Add("id", userId.ToString());
//Act
var result = await ControllerUnderTest.Update(user);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task CreateIssueAsync_Should_Return_CreatedAtActionResult_With_The_created_Issue_Test()
{
// Arrange
var expectedCreatedAtActionName = nameof(IssueController.IssueByIdAsync);
var issueToCreate = new IssueForCreationDto {
IssueDescription = "Test 1"
};
var expectedResult = new IssueDto {
Id = 1, IssueDescription = "Test 1"
};
IssueServiceMock
.Setup(x => x.CreateIssueAsync(issueToCreate))
.ReturnsAsync(expectedResult);
// Act
var result = await ControllerUnderTest.CreateIssueAsync(issueToCreate);
// Assert
var createdResult = Assert.IsType <CreatedAtRouteResult>(result);
Assert.Same(expectedResult, createdResult.Value);
Assert.Equal(expectedCreatedAtActionName, createdResult.RouteName);
Assert.Equal(expectedResult.Id, createdResult.RouteValues.GetValueOrDefault("id")
);
}