public void Should_Validate_publisher_Different_From_Authors()
{
var bookPublishValidator = Resolve <IBookPublishValidator>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var anotherPublisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(publisher)
.Build();
var book = new BookBuilder()
.Build();
var authorBook = new AuthorBookBuilder().WithAuthor(author).WithBook(book).Build();
AddEntities(publisher, anotherPublisher, author, book, authorBook);
book = bookRepository.Get(book.Id).FirstOrDefault();
Action act = () => bookPublishValidator.ValidatePublish(book, anotherPublisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"{Environment.NewLine}The publisher of publication's book must be from one of the authors!");
}
public void Should_Validate_Publish_With_Excedent_Authors()
{
var bookPublishValidator = Resolve <IBookPublishValidator>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var authorBuilder = new AuthorBuilder().WithPublisher(publisher);
var author = authorBuilder.Build();
var author2 = authorBuilder.Build();
var author3 = authorBuilder.Build();
var author4 = authorBuilder.Build();
var book = new BookBuilder().Build();
var authorBookBuilder = new AuthorBookBuilder().WithBook(book);
var authorBook = authorBookBuilder.WithAuthor(author).Build();
var authorBook2 = authorBookBuilder.WithAuthor(author2).Build();
var authorBook3 = authorBookBuilder.WithAuthor(author3).Build();
var authorBook4 = authorBookBuilder.WithAuthor(author4).Build();
var authorsBook = new List <AuthorBookEntity> {
authorBook, authorBook2, authorBook3, authorBook4
};
AddEntities(publisher, author, author2, author3, author4, book, authorBook, authorBook2, authorBook3, authorBook4);
book = bookRepository.Get(book.Id).FirstOrDefault();
Action act = () => bookPublishValidator.ValidatePublish(book, publisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book can't have more than 3 authors!");
}
[TestMethod, Ignore] // Only VS Premium and Ultimate has Fakes
public void TestWithShivCompleteDependantRepository()
{
var author = new AuthorBuilder().CliveCustler().Build();
var request = new BookBuilder().DeepSix().BuildRequest();
Book response;
using (ShimsContext.Create())
{
// Create SHIV
var stubAuthRepo = new Contracts.Fakes.StubIAuthorRepository
{
// Method = (parameters) => { method }
GetAuthorByIdGuid = id => author
};
// SHIM the property that retrieves the repository
ShimBookRepository.AllInstances.AuthorRepoGet = _ => stubAuthRepo;
var repo = new BookRepository();
response = repo.AddBook(request);
}
Assert.IsNotNull(response);
Assert.AreEqual(author, response.Author);
}
public async Task ShouldBeReturnedAuthenticationResultWithSuccessAndCreatedNewAuthor()
{
var salt = SecurePasswordHasher.CreateSalt(8);
var newAuthor = new AuthorBuilder()
.WithFirstName(_faker.Person.FirstName)
.WithLastName(_faker.Person.LastName)
.WithUsername(_faker.Person.UserName)
.WithEmail(_faker.Person.Email)
.WithPassword(SecurePasswordHasher.GenerateHash("joao123", salt))
.WithSalt(salt)
.Build();
var authenticationResult = await _authenticationService.RegisterAsync(newAuthor);
authenticationResult.Should().BeOfType <AuthenticationResult>();
authenticationResult.Success.Should().BeTrue();
authenticationResult.Errors.Should().BeNull();
authenticationResult.Token.Should().NotBeNullOrEmpty();
_output.WriteLine($"Success: {authenticationResult.Success} | Token: {authenticationResult.Token}");
// Verificando se o autor foi inserido no banco de dados
var insertedAuthor = await _unitOfWork.Authors
.FindByConditionAsync(a => a.Id == newAuthor.Id)
.Result.SingleOrDefaultAsync();
insertedAuthor.Should().NotBeNull();
insertedAuthor.FirstName.Should().Be(newAuthor.FirstName);
insertedAuthor.Username.Should().Be(newAuthor.Username);
insertedAuthor.Email.Should().Be(newAuthor.Email);
}
public void Should_Validate_Publish_With_Excedent_Authors()
{
_publisher = new PublisherBuilder().Build();
var authorBuilder = new AuthorBuilder().WithPublisher(_publisher);
var author = authorBuilder.Build();
var author2 = authorBuilder.Build();
var author3 = authorBuilder.Build();
var author4 = authorBuilder.Build();
_book = new BookBuilder().Build();
var authorBookBuilder = new AuthorBookBuilder().WithBook(_book);
var authorBook = authorBookBuilder.WithAuthor(author).Build();
var authorBook2 = authorBookBuilder.WithAuthor(author2).Build();
var authorBook3 = authorBookBuilder.WithAuthor(author3).Build();
var authorBook4 = authorBookBuilder.WithAuthor(author4).Build();
var authorsBook = new List <AuthorBookEntity> {
authorBook, authorBook2, authorBook3, authorBook4
};
_book.AuthorsBook = authorsBook;
Action act = () => _bookPublishValidator.ValidatePublish(_book, _publisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book can't have more than 3 authors!");
}
public void Should_Validate_Book_Already_Published()
{
_publisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(_publisher)
.Build();
_book = new BookBuilder()
.WithPublisher(_publisher)
.Build();
var authorBook = new AuthorBookBuilder().WithAuthor(author).WithBook(_book).Build();
var authorsBook = new List <AuthorBookEntity> {
authorBook
};
_book.AuthorsBook = authorsBook;
Action act = () => _bookPublishValidator.ValidatePublish(_book, _publisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book ({_book.Id}) is already published!");
}
public void Should_Validate_Publish_With_Excedent_Authors()
{
var bookBll = Resolve <IBookBll>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var authorBuilder = new AuthorBuilder().WithPublisher(publisher);
var author = authorBuilder.Build();
var author2 = authorBuilder.Build();
var author3 = authorBuilder.Build();
var author4 = authorBuilder.Build();
var book = new BookBuilder().Build();
var authorBookBuilder = new AuthorBookBuilder().WithBook(book);
var authorBook = authorBookBuilder.WithAuthor(author).Build();
var authorBook2 = authorBookBuilder.WithAuthor(author2).Build();
var authorBook3 = authorBookBuilder.WithAuthor(author3).Build();
var authorBook4 = authorBookBuilder.WithAuthor(author4).Build();
var authorsBook = new List <AuthorBookEntity> {
authorBook, authorBook2, authorBook3, authorBook4
};
AddEntities(publisher, author, author2, author3, author4, book, authorBook, authorBook2, authorBook3, authorBook4);
Action act = () => bookBll.PublishBook(book.Id, new PublishBookRequestDTO {
PublishierId = publisher.Id
});
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book can't have more than 3 authors!");
}
public void Should_Validate_Publisher_Different_From_Authors()
{
_publisher = new PublisherBuilder().Build();
var anotherPublisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(_publisher)
.Build();
_book = new BookBuilder()
.Build();
var authorBook = new AuthorBookBuilder().WithAuthor(author).WithBook(_book).Build();
var authorsBook = new List <AuthorBookEntity> {
authorBook
};
_book.AuthorsBook = authorsBook;
Action act = () => _bookPublishValidator.ValidatePublish(_book, anotherPublisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"{Environment.NewLine}The publisher of publication's book must be from one of the authors!");
}
public void Should_Validatebook_Already_Published()
{
var bookBll = Resolve <IBookBll>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(publisher)
.Build();
var book = new BookBuilder()
.WithPublisher(publisher)
.Build();
var authorBook = new AuthorBookBuilder()
.WithAuthor(author)
.WithBook(book)
.Build();
AddEntities(publisher, author, book, authorBook);
Action act = () => bookBll.PublishBook(book.Id, new PublishBookRequestDTO {
PublishierId = publisher.Id
});
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book ({book.Id}) is already published!");
}
public void Should_Validate_Publisher_Different_From_Authors()
{
var bookBll = Resolve <IBookBll>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var anotherPublisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(publisher)
.Build();
var book = new BookBuilder()
.Build();
var authorBook = new AuthorBookBuilder().WithAuthor(author).WithBook(book).Build();
AddEntities(publisher, anotherPublisher, author, book, authorBook);
Action act = () => bookBll.PublishBook(book.Id, new PublishBookRequestDTO {
PublishierId = anotherPublisher.Id
});
act.Should()
.Throw <BusinessException>()
.WithMessage($"{Environment.NewLine}The publisher of publication's book must be from one of the authors!");
}
public async Task Setup()
{
var author = AuthorBuilder.WithLibrary(LibraryId).Build();
var series = SeriesBuilder.WithLibrary(LibraryId).Build();
var categories = CategoryBuilder.WithLibrary(LibraryId).Build(3);
var book = new BookView
{
Title = RandomData.Name,
Authors = new List <AuthorView> {
new AuthorView {
Id = author.Id
}
},
SeriesId = series.Id,
SeriesIndex = 1,
SeriesName = series.Name,
Language = RandomData.Locale,
Categories = RandomData.PickRandom(categories, 2).Select(c => new CategoryView {
Id = c.Id
})
};
_response = await Client.PostObject($"/libraries/{LibraryId}/books", book);
_bookAssert = BookAssert.WithResponse(_response).InLibrary(LibraryId);
}
public async Task Setup()
{
var authors = AuthorBuilder.WithLibrary(LibraryId).Build(4);
var expected = authors.PickRandom();
_response = await Client.DeleteAsync($"/libraries/{LibraryId}/authors/{expected.Id}");
}
public Book FindById(Guid id)
{
var bookEntity = _dbContext.Books.Include(b => b.Author).FirstOrDefault(b => b.Id == id);
if (bookEntity == null)
{
return(null);
}
var authorEntity = bookEntity.Author;
var author = AuthorBuilder.CreateNew()
.WithId(authorEntity.Id)
.WithFirstName(authorEntity.FirstName)
.WithLastName(authorEntity.LastName)
.Build();
return(BookBuilder.CreateNew()
.WithId(bookEntity.Id)
.WithTitle(bookEntity.Title)
.WithIsbn13(bookEntity.Isbn)
.WithReleaseDate(bookEntity.ReleaseDate)
.WithPublisher(bookEntity.Publisher)
.WithAuthor(author)
.Build());
}
public void Should_Validate_Author_Without_Publisher()
{
var bookPublishValidator = Resolve <IBookPublishValidator>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.Build();
var book = new BookBuilder()
.Build();
var authorBook = new AuthorBookBuilder().WithAuthor(author).WithBook(book).Build();
AddEntities(publisher, author, book, authorBook);
book = bookRepository.Get(book.Id).FirstOrDefault();
Action act = () => bookPublishValidator.ValidatePublish(book, publisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"The following authors do not have publishers on his register:{Environment.NewLine}{author.FirstName}" +
$"{Environment.NewLine}The publisher of publication's book must be from one of the authors!");
}
public void Should_Validatebook_Already_Published()
{
var bookPublishValidator = Resolve <IBookPublishValidator>();
var bookRepository = Resolve <IBookRepository>();
var publisher = new PublisherBuilder().Build();
var author = new AuthorBuilder()
.WithPublisher(publisher)
.Build();
var book = new BookBuilder()
.WithPublisher(publisher)
.Build();
var authorBook = new AuthorBookBuilder()
.WithAuthor(author)
.WithBook(book)
.Build();
AddEntities(publisher, author, book, authorBook);
book = bookRepository.Get(book.Id).FirstOrDefault();
Action act = () => bookPublishValidator.ValidatePublish(book, publisher);
act.Should()
.Throw <BusinessException>()
.WithMessage($"Book ({book.Id}) is already published!");
}
public async Task Setup()
{
AuthorBuilder.WithLibrary(LibraryId).WithBooks(3).WithoutImage().Build(4);
_response = await Client.GetAsync($"/libraries/{LibraryId}/authors");
_assert = new PagingAssert <AuthorView>(_response);
}
public async Task Setup()
{
AuthorBuilder.WithLibrary(LibraryId).WithBooks(3).Build(20);
_response = await Client.GetAsync($"/libraries/{LibraryId}/authors?pageNumber={100}&pageSize={10}");
_assert = new PagingAssert <AuthorView>(_response);
}
public async Task Setup()
{
var author = AuthorBuilder.WithLibrary(LibraryId).Build();
author.Name = RandomData.Name;
_response = await Client.PutObject($"/libraries/{LibraryId}/authors/{author.Id}", author);
}
public async Task Setup()
{
var author = AuthorBuilder.WithLibrary(LibraryId).Build();
_authorId = author.Id;
_newImage = RandomData.Bytes;
_response = await Client.PutFile($"/libraries/{LibraryId}/authors/{_authorId}/image", _newImage);
}
public async Task Setup()
{
AuthorBuilder.WithLibrary(LibraryId).WithBooks(3).WithNamePattern("SearchAuthor").Build(5);
_response = await Client.GetAsync($"/libraries/{LibraryId}/authors?query=SearchAuthor&pageNumber={1}&pageSize={10}");
_assert = new PagingAssert <AuthorView>(_response);
}
public void TestDataWithStaticIdsTest()
{
var authorList = new AuthorBuilder().BuildAll();
// Builders & Repositories generate new IDs so it is important to be able to match with different ID
var findAuthorThatWasCreatedUsingBuilder = authorList.FirstOrDefault(auth => auth.Surname.Contains("Gold"));
var comparisonAuthor = new AuthorBuilder(findAuthorThatWasCreatedUsingBuilder?.Id).EliyahuGoldratt().Build();
Assert.IsTrue(comparisonAuthor.Equals(findAuthorThatWasCreatedUsingBuilder));
}
public async Task Setup()
{
_author = AuthorBuilder.WithLibrary(LibraryId).Build();
_authorBooks = BookBuilder.WithLibrary(LibraryId).WithAuthor(_author).IsPublic().Build(1);
AuthorBuilder.WithLibrary(LibraryId).WithBooks(3).Build();
_response = await Client.GetAsync($"/libraries/{LibraryId}/books?pageNumber=20&pageSize=10&authorId={_author.Id}");
_assert = new PagingAssert <BookView>(_response);
}
public async Task Setup()
{
var authors = AuthorBuilder.WithLibrary(LibraryId).Build(4);
_expected = authors.PickRandom();
_response = await Client.GetAsync($"/libraries/{LibraryId}/authors/{_expected.Id}");
_assert = AuthorAssert.WithResponse(_response).InLibrary(LibraryId);
}
public async Task Setup()
{
var authors = AuthorBuilder.WithLibrary(LibraryId).WithBooks(3).WithoutImage().Build(20);
_searchedAuthor = authors.PickRandom();
_response = await Client.GetAsync($"/libraries/{LibraryId}/authors?query={_searchedAuthor.Name}");
_assert = new PagingAssert <AuthorView>(_response);
}
public async Task Setup()
{
_categories = CategoryBuilder.WithLibrary(LibraryId).Build(2);
_authors = AuthorBuilder.WithLibrary(LibraryId).Build(2);
_books = BookBuilder.WithLibrary(LibraryId).WithCategories(_categories).WithAuthors(_authors).IsPublic().Build(12);
_response = await Client.GetAsync($"/libraries/{LibraryId}/books?pageNumber=1&pageSize=10&sortby=DateCreated&sort=Ascending");
_assert = new PagingAssert <BookView>(_response);
}
public void AddAuthorWithSuccess()
{
var repo = RepositoryFactory.CreateAuthorRepository();
var request = new AuthorBuilder().AuthorOne().BuildRequest();
var response = repo.AddAuthor(request);
var found = Database.Authors.FirstOrDefault(auth => auth.Id == response.Id);
Assert.AreEqual(response, found);
}
public static async Task <Author> PersistAuthor(this ContainerFixture containerFixture)
{
var author = new AuthorBuilder().Build();
await containerFixture.ExecuteDbContextAsync(async context =>
{
context.Auhtors.Add(author);
await context.SaveChangesAsync();
});
return(author);
}
public static AuthorBuilder BuildAuthorByRequest(this AuthorBuilder authorBuilder, CreateAuthorRequest request)
{
return(authorBuilder?
.WithFirstName(request?.FirstName)
.WithLastName(request?.LastName)
.WithUsername(request?.Username)
.WithPassword(request?.Password)
.WithEmail(request?.Email)
.WithBio(request?.Bio)
.WithAvatar(request?.Avatar));
}
public async Task Setup()
{
_categories = CategoryBuilder.WithLibrary(LibraryId).Build(2);
_authors = AuthorBuilder.WithLibrary(LibraryId).Build(2);
BookBuilder.WithLibrary(LibraryId).WithCategories(_categories).WithAuthors(_authors).IsPublic().Build(30);
_response = await Client.GetAsync($"/libraries/{LibraryId}/books?pageNumber=2&pageSize=10&query=itle");
_assert = new PagingAssert <BookView>(_response);
}
public async Task ShouldBeNotCreatedAuthorWithEqualsEmailOrUsername()
{
var existingAuthor = new AuthorBuilder()
.WithFirstName("Maria")
.WithUsername("mmaria")
.WithEmail("*****@*****.**")
.Build();
var created = await _authorService.CreateAuthorAsync(existingAuthor);
created.Should().BeFalse();
_dbContext.Authors.Should().HaveCount(2);
}
