public void DeleteAnnouncement_Should_Success()
{
var author = new BookCreatorUser()
{
UserName = "******",
Name = "Goshko Petkov"
};
var announcementInput = new AnnouncementInputModel()
{
Content = "newnew",
Author = author.UserName
};
var newAnnouncementId = this.adminService.AddAnnouncement(announcementInput);
var announcement = this.Context.Announcements.Find(newAnnouncementId);
this.adminService.DeleteAnnouncement(newAnnouncementId);
var result = this.Context.Announcements.ToList();
result.Should().BeEmpty()
.And.Subject.Should().NotContain(announcement);
}
public void SendMessage_Should_Success()
{
var sender = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Petkov"
};
var receiver = new BookCreatorUser()
{
UserName = "******",
Name = "Petko Goshov"
};
this.userManager.CreateAsync(sender).GetAwaiter();
this.userManager.CreateAsync(receiver).GetAwaiter();
this.Context.SaveChanges();
var messageInput = new MessageInputModel
{
SenderName = sender.UserName,
ReceiverName = receiver.UserName,
Message = "ko staa we",
SendDate = DateTime.UtcNow
};
var newMessageId = this.messageService.SendMessage(messageInput);
var result = this.Context.Messages.First();
result.Should().NotBeNull()
.And.Subject.As <Message>()
.Id.Should().Be(newMessageId);
}
public void FollowingCount_Should_Return_Correct()
{
var book = new Book()
{
Id = "1",
Author = null,
Summary = "summary",
Title = "title"
};
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
this.Context.Books.Add(book);
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var bookId = book.Id;
var userId = user.Id;
var username = user.UserName;
bookService.Follow(username, userId, bookId).GetAwaiter().GetResult();
var result = this.bookService.FollowingCount(book.Id);
result.Should().BeGreaterThan(0);
}
public async Task Unfollow_Should_Throw_Error_Missing_UserBook()
{
var book = new Book()
{
Id = "1",
Author = null,
Summary = "summary",
Title = "title"
};
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
await userManager.CreateAsync(user);
this.Context.Books.Add(book);
this.Context.SaveChanges();
var userId = user.Id;
var bookId = book.Id;
Func <Task> act = async() => await bookService.UnFollow(userId, bookId);
await act.Should().ThrowAsync <ArgumentNullException>();
}
public void AddComment_Should_Success()
{
var user = new BookCreatorUser
{
UserName = "******",
Name = "Georgi Goshkov"
};
userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var commentInput = new CommentInputModel
{
BookId = "1",
CommentAuthor = user.UserName,
CommentedOn = DateTime.UtcNow,
Message = "asd"
};
this.commentService.AddComment(commentInput);
var result = this.Context.Comments.First();
result.Should().NotBeNull()
.And.Subject.As <Comment>()
.Message.Should().Be(commentInput.Message);
}
public void AddAnnouncement_Should_Success()
{
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Goshko Petkov"
};
var announcements = new[]
{
new Announcement
{
Id = "2",
Content = "content1",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow
},
new Announcement
{
Id = "3",
Content = "content2",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow.AddHours(2)
},
new Announcement
{
Id = "4",
Content = "content3",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow.AddHours(7)
},
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.Announcements.AddRange(announcements);
this.Context.SaveChanges();
var newAnnouncement = new AnnouncementInputModel
{
Author = user.UserName,
Content = "new"
};
var newAnnouncementId = this.adminService.AddAnnouncement(newAnnouncement);
var announcementCompareTo = new Announcement()
{
Id = newAnnouncementId,
AuthorId = user.Id,
Author = user,
Content = newAnnouncement.Content,
PublishedOn = DateTime.UtcNow
};
var result = this.Context.Announcements.Find(newAnnouncementId);
result.Should().NotBeNull()
.And.BeEquivalentTo(announcementCompareTo,
options => options.Excluding(x => x.PublishedOn));
}
public void GetUsersCount_Should_Return_Correct_Count()
{
var user1 = new BookCreatorUser()
{
Id = "1",
UserName = "******",
Name = "Vankata Ivanov"
};
var user2 = new BookCreatorUser()
{
Id = "2",
UserName = "******",
Name = "Ivan Vankov"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
var usersCount = 2;
var result = this.adminService.GetUsersCount();
result.Should().Be(usersCount);
}
public void DeleteUser_Should_Throw_Error_User_NotFound()
{
var user1 = new BookCreatorUser()
{
Id = "1",
UserName = "******",
Name = "Vankata Ivanov"
};
var user2 = new BookCreatorUser()
{
Id = "2",
UserName = "******",
Name = "Ivan Vankov"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
var userIdToDelete = "asdasd";
Func <Task> act = async() => await this.adminService.DeleteUser(userIdToDelete);
act.Should().Throw <ArgumentException>().WithMessage(GlobalConstants.ErrorOnDeleteUser);
}
public void DeleteBook_Throw_Error_Lack_Rights()
{
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
var author = new BookCreatorUser()
{
Id = "321",
Name = "Kuncho Papunchev",
UserName = "******"
};
var book = new Book()
{
Id = "1",
AuthorId = author.Id,
Summary = "summary",
Title = "title"
};
userManager.CreateAsync(user).GetAwaiter();
userManager.CreateAsync(author).GetAwaiter();
this.Context.Books.Add(book);
this.Context.SaveChanges();
Func <Task> act = async() => await bookService.DeleteBook(book.Id, user.UserName);
act.Should().Throw <OperationCanceledException>();
}
public void Register_Should_Fail_Duplicate_Username()
{
var registerModel = new RegisterInputModel()
{
Username = "******",
Name = "Ivan Goshkov",
Password = "******",
ConfirmPassword = "******",
Email = "*****@*****.**"
};
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Goshko Ivanov",
Email = "*****@*****.**"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
this.roleService.CreateAsync(new IdentityRole {
Name = GlobalConstants.DefaultRole
}).GetAwaiter();
var result = this.userService.RegisterUser(registerModel).GetAwaiter().GetResult();
result.Should().BeEquivalentTo(SignInResult.Failed);
}
public void DeleteUser_Should_Success()
{
var user1 = new BookCreatorUser()
{
Id = "1",
UserName = "******",
Name = "Vankata Ivanov"
};
var user2 = new BookCreatorUser()
{
Id = "2",
UserName = "******",
Name = "Ivan Vankov"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
this.adminService.DeleteUser(user1.Id);
var users = this.Context.Users.ToList();
users.Should().ContainSingle()
.And.Subject.Should().NotContain(user1);
}
public void DeleteBook_Throw_Error_NonExisting_Book()
{
var admin = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
var author = new BookCreatorUser()
{
Id = "321",
Name = "Kuncho Papunchev",
UserName = "******"
};
userManager.CreateAsync(admin).GetAwaiter();
userManager.CreateAsync(author).GetAwaiter();
var role = new IdentityRole {
Name = "admin"
};
roleManager.CreateAsync(role).GetAwaiter();
userManager.AddToRoleAsync(admin, role.Name).GetAwaiter();
this.Context.SaveChanges();
Func <Task> act = async() => await bookService.DeleteBook("1", admin.UserName);
act.Should().ThrowAsync <InvalidOperationException>().Wait();
}
public void IsBlocked_Should_Return_Correct_Result()
{
var user1 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov1",
Email = "*****@*****.**"
};
var user2 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Ivanov",
Email = "*****@*****.**"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
this.userService.BlockUser(user1.UserName, user2.UserName).GetAwaiter().GetResult();
var result = this.userService.IsBlocked(user1.UserName, user2.UserName);
result.Should().BeTrue();
}
public void Unblock_Should_Throw_Error()
{
var user1 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov",
Email = "*****@*****.**"
};
var user2 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov",
Email = "*****@*****.**"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
var bookCreatorId = user1.Id;
var blockedBookCreatorId = user2.Id;
Action act = () => this.userService.UnblockUser(bookCreatorId, blockedBookCreatorId);
act.Should().Throw <InvalidOperationException>()
.WithMessage(GlobalConstants.NoRecordInDb);
}
public void AddNotification_Should_Success_When_NewChapter_Added()
{
var user1 = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Goshev"
};
var user2 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Ivanov"
};
var book = new Book()
{
Id = "1",
Title = "title1",
Summary = "summary1",
CreatedOn = DateTime.UtcNow,
ImageUrl = GlobalConstants.NoImageAvailableUrl,
Genre = new BookGenre()
{
Genre = "Horror"
},
AuthorId = "111"
};
var userBook1 = new UserBook()
{
UserId = user1.Id,
BookId = book.Id
};
var userBook2 = new UserBook()
{
UserId = user2.Id,
BookId = book.Id
};
book.Followers.Add(userBook1);
book.Followers.Add(userBook2);
userManager.CreateAsync(user1).GetAwaiter();
userManager.CreateAsync(user2).GetAwaiter();
this.Context.Books.Add(book);
this.Context.UsersBooks.Add(userBook1);
this.Context.UsersBooks.Add(userBook2);
this.Context.SaveChanges();
this.notificationService.AddNotification(book.Id, null, book.Title);
var result = this.Context.UsersBooks.ToList();
result.Should().NotBeEmpty().And.HaveCount(2);
result[0].User.Should().BeEquivalentTo(user1);
result[1].User.Should().BeEquivalentTo(user2);
}
public async Task Follow_Throw_Error_Duplicate_Entity()
{
var book = new Book()
{
Id = "1",
Author = null,
Summary = "summary",
Title = "title"
};
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
this.Context.Books.Add(book);
await userManager.CreateAsync(user);
this.Context.SaveChanges();
var bookId = book.Id;
var userId = user.Id;
var username = user.UserName;
await bookService.Follow(username, userId, bookId);
Action act = () => bookService.Follow(username, userId, bookId).GetAwaiter().GetResult();
string message = string.Join(GlobalConstants.AlreadyFollowed, user.UserName);
act.Should().Throw <InvalidOperationException>().WithMessage(message);
}
public void AdminModifyRole_Should_Success()
{
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Goshko Petkov"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var roles = new[]
{
"admin",
"user"
};
foreach (var currentRolename in roles)
{
var role = new IdentityRole
{
Name = currentRolename
};
this.roleService.CreateAsync(role).GetAwaiter();
}
var result = this.adminService.AdminModifyRole(user.Id);
result.Should().Equals(IdentityResult.Success);
}
public void GetReceivedMessages_Should_Return_Success()
{
var sender = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Petkov"
};
var receiver = new BookCreatorUser()
{
UserName = "******",
Name = "Petko Goshov"
};
this.userManager.CreateAsync(sender).GetAwaiter();
this.userManager.CreateAsync(receiver).GetAwaiter();
this.Context.SaveChanges();
var messages = new[]
{
new Message()
{
Id = "1",
IsRead = false,
ReceiverId = receiver.Id,
SenderId = sender.Id,
SentOn = DateTime.UtcNow,
Text = "asdasd"
},
new Message()
{
Id = "2",
IsRead = false,
ReceiverId = receiver.Id,
SenderId = sender.Id,
SentOn = DateTime.UtcNow,
Text = "qweqwewqe"
},
new Message()
{
Id = "1",
IsRead = false,
ReceiverId = sender.Id,
SenderId = receiver.Id,
SentOn = DateTime.UtcNow,
Text = "asdasd"
},
};
var result = this.messageService.GetReceivedMessages(receiver.Id);
var mappedMessages = Mapper.Map <IList <MessageOutputModel> >(messages);
var expectedResult = mappedMessages.Take(2).ToList();
result.Should().NotBeNull()
.And.Subject.Equals(expectedResult);
result.Should().Subject.Count().Equals(messages.Length - 1);
}
public void DeleteChapter_Should_Throw_Error_NoRights()
{
var user1 = new BookCreatorUser
{
UserName = "******",
Name = "Gosho Ivanov"
};
var user2 = new BookCreatorUser
{
UserName = "******",
Name = "Gosho Ivanov"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.Context.SaveChanges();
var book = new Book
{
Id = "1",
Summary = "asd",
Title = "asdasd",
AuthorId = user2.Id
};
var chapters = new[]
{
new Chapter()
{
Id = "1",
AuthorId = user2.Id,
BookId = book.Id,
Title = "asdasd",
Content = "contentfsdf",
CreatedOn = DateTime.UtcNow
},
new Chapter()
{
Id = "2",
AuthorId = user2.Id,
BookId = book.Id,
Title = "dasd",
Content = "gdfgdfg",
CreatedOn = DateTime.UtcNow
},
};
this.Context.Chapters.AddRange(chapters);
this.Context.Books.Add(book);
this.Context.SaveChanges();
Action act = () => this.chapterService.DeleteChapter(book.Id, chapters[0].Id, user1.UserName);
string message = GlobalConstants.UserHasNoRights + " " + GlobalConstants.NotAuthor;
act.Should().Throw <InvalidOperationException>().WithMessage(message);
}
public void AddChapter_Should_Success()
{
var user = new BookCreatorUser
{
UserName = "******",
Name = "Gosho Ivanov"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var book = new Book
{
Id = "1",
Summary = "asd",
Title = "asdasd",
AuthorId = user.Id
};
var chapter = new Chapter
{
Id = "2",
Content = "content2",
AuthorId = user.Id,
BookId = book.Id,
Title = "title2",
CreatedOn = DateTime.UtcNow
};
var chapterInputModel = new ChapterInputModel
{
Author = user.UserName,
BookId = book.Id,
Content = "newnew",
CreatedOn = DateTime.UtcNow,
Title = "newnewTitle"
};
this.Context.Chapters.Add(chapter);
this.Context.Books.Add(book);
this.Context.SaveChanges();
var newChapterId = this.chapterService.AddChapter(chapterInputModel);
var result = this.Context.Chapters.Find(newChapterId);
result.Should().NotBeNull()
.And.Subject.Should()
.BeOfType <Chapter>();
}
public void BlockedUsers_Should_Return_Correct_Count()
{
var user1 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov",
Email = "*****@*****.**"
};
var user2 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov",
Email = "*****@*****.**"
};
var user3 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov",
Email = "*****@*****.**"
};
this.userManager.CreateAsync(user1).GetAwaiter();
this.userManager.CreateAsync(user2).GetAwaiter();
this.userManager.CreateAsync(user3).GetAwaiter();
var blockedUsers = new[]
{
new BlockedUser()
{
BookCreatorUser = user1,
BlockedBookCreatorUser = user2
},
new BlockedUser()
{
BookCreatorUser = user1,
BlockedBookCreatorUser = user3
}
};
this.Context.BlockedUsers.AddRange(blockedUsers);
this.Context.SaveChanges();
var count = blockedUsers.Length;
var userId = user1.Id;
var result = this.userService.BlockedUsers(userId);
result.Should().NotBeNullOrEmpty()
.And.HaveCount(count);
}
public void DeleteComment_Should_Success()
{
var user = new BookCreatorUser
{
UserName = "******",
Name = "Georgi Goshkov"
};
userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var genre = new BookGenre()
{
Id = "1",
Genre = "Horror"
};
var book = new Book()
{
Id = "1",
Title = "title1",
CreatedOn = DateTime.UtcNow,
Summary = "summary1",
ImageUrl = GlobalConstants.NoImageAvailableUrl,
Genre = genre,
AuthorId = user.Id
};
var comment = new Comment()
{
Id = "1",
BookId = book.Id,
UserId = user.Id,
CommentedOn = DateTime.UtcNow,
Message = "asdasd"
};
this.Context.Comments.Add(comment);
this.Context.Books.Add(book);
this.Context.BooksGenres.Add(genre);
this.Context.SaveChanges();
this.commentService.DeleteComment(comment.Id);
var result = this.Context.Comments.ToList();
result.Should().BeEmpty();
}
public void GetChapterToEdit_Return_ChapterEditModel_From_Id()
{
var user = new BookCreatorUser
{
UserName = "******",
Name = "Gosho Ivanov"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var book = new Book
{
Id = "1",
Summary = "asd",
Title = "asdasd",
AuthorId = user.Id
};
var chapter = new Chapter
{
Id = "1",
Content = "content1",
AuthorId = user.Id,
BookId = book.Id,
Title = "title1",
CreatedOn = DateTime.UtcNow
};
var chapterEditModel = new ChapterEditModel
{
Id = chapter.Id,
Author = user.UserName,
Content = chapter.Content,
CreatedOn = chapter.CreatedOn,
BookId = book.Id,
Title = chapter.Title
};
this.Context.Chapters.Add(chapter);
this.Context.Books.Add(book);
this.Context.SaveChanges();
var result = this.chapterService.GetChapterToEdit(chapter.Id);
result.Should().NotBeNull()
.And.Subject.Should().Equals(chapterEditModel);
}
public void GetNotifications_Should_Success()
{
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Goshev"
};
var notifications = new[]
{
new Notification()
{
Id = "1",
UserId = user.Id,
Seen = true,
Message = GlobalConstants.NotificationMessageNewChapter,
UpdatedBookId = "1"
},
new Notification()
{
Id = "2",
UserId = user.Id,
Seen = false,
Message = GlobalConstants.NotificationMessageNewChapter,
UpdatedBookId = "2"
},
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.Notifications.AddRange(notifications);
this.Context.SaveChanges();
var result = this.notificationService.GetNotifications(user.Id).First();
var notification = notifications[0];
var expectedResult = new NotificationOutputModel
{
Id = notification.Id,
Message = notification.Message,
Seen = notification.Seen,
UpdatedBookId = notification.UpdatedBookId,
Username = notification.User.UserName
};
result.Should().NotBeNull()
.And.Equals(expectedResult);
}
public void CreateBook_Success_Without_Image()
{
var author = new BookCreatorUser()
{
Id = "123",
Name = "Nagatomo Gazaki",
UserName = "******"
};
var genre = new BookGenre()
{
Id = "1",
Genre = "Horror"
};
userManager.CreateAsync(author).GetAwaiter();
this.Context.BooksGenres.Add(genre);
this.Context.SaveChanges();
var bookInputModel = new BookInputModel()
{
Author = author.UserName,
BookCoverImage = null,
CreatedOn = DateTime.UtcNow,
Genre = genre.Genre,
Summary = "summary",
Title = "title"
};
var result = bookService.CreateBook(bookInputModel).GetAwaiter().GetResult();
var book = this.Context.Books.FirstOrDefault();
result.Should().NotBeNull();
book.Should().NotBeNull().And.Subject.Should().BeEquivalentTo(new
{
Id = result,
ImageUrl = GlobalConstants.NoImageAvailableUrl,
bookInputModel.Title,
Genre = new BookGenreOutputModel()
{
Id = "1",
GenreName = bookInputModel.Genre
}
}, options => options.ExcludingMissingMembers());
}
public void GetName_Should_Return_Correct_Name()
{
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Goshkov1",
Email = "*****@*****.**"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
var result = this.userService.GetName(user.Id);
result.Should().NotBeNull()
.And.Subject.Should().Equals(user.Name);
}
public void AllAnnouncements_Should_Return_Correct_Count()
{
var user = new BookCreatorUser()
{
UserName = "******",
Name = "Goshko Petkov"
};
var announcements = new[]
{
new Announcement
{
Id = "1",
Content = "content1",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow
},
new Announcement
{
Id = "2",
Content = "content2",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow.AddHours(2)
},
new Announcement
{
Id = "3",
Content = "content3",
AuthorId = user.Id,
PublishedOn = DateTime.UtcNow.AddHours(7)
},
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.Announcements.AddRange(announcements);
this.Context.SaveChanges();
var result = this.adminService.AllAnnouncements();
var count = announcements.Length;
result.Announcements.Should().NotBeEmpty()
.And.HaveCount(count)
.And.ContainItemsAssignableTo <AnnouncementOutputModel>();
}
public void DeleteBook_Success_OnlyAdmin()
{
var admin = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
var author = new BookCreatorUser()
{
Id = "321",
Name = "Kuncho Papunchev",
UserName = "******"
};
var book = new Book()
{
Id = "1",
AuthorId = author.Id,
Summary = "summary",
Title = "title"
};
userManager.CreateAsync(admin).GetAwaiter();
userManager.CreateAsync(author).GetAwaiter();
var role = new IdentityRole {
Name = "admin"
};
roleManager.CreateAsync(role).GetAwaiter();
userManager.AddToRoleAsync(admin, role.Name).GetAwaiter();
this.Context.Books.Add(book);
this.Context.SaveChanges();
bookService.DeleteBook(book.Id, admin.UserName);
var result = this.Context.Books.FirstOrDefault();
result.Should().BeNull();
}
public async Task AddRating_Should_Success()
{
var book = new Book()
{
Id = "1",
Author = null,
Summary = "summary",
Title = "title"
};
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
await userManager.CreateAsync(user);
this.Context.Books.Add(book);
this.Context.SaveChanges();
var bookId = book.Id;
var rating = 9.5;
var username = user.UserName;
var ratingId = bookService.AddRating(bookId, rating, username);
var bookRating = new BookRating()
{
RatingId = ratingId,
BookId = bookId
};
var result = this.Context.BooksRatings.FirstOrDefault();
result.Should().NotBeNull()
.And.Subject.Should()
.BeOfType <BookRating>()
.And.Should()
.BeEquivalentTo(bookRating, x => x.ExcludingMissingMembers());
}
public void AddRating_Should_Throw_Exception_AlreadyRated()
{
var book = new Book()
{
Id = "1",
Author = null,
Summary = "summary",
Title = "title"
};
var user = new BookCreatorUser()
{
Id = "123",
Name = "Papuncho Kunchev",
UserName = "******"
};
var rating = new UserRating()
{
Id = "1",
UserId = user.Id,
Rating = 9.5
};
var bookRating = new BookRating()
{
RatingId = rating.Id,
BookId = book.Id
};
userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.Books.Add(book);
this.Context.BooksRatings.Add(bookRating);
this.Context.UsersRatings.Add(rating);
this.Context.SaveChanges();
Action act = () => bookService.AddRating(book.Id, 2.00, user.UserName);
act.Should().Throw <InvalidOperationException>().WithMessage(GlobalConstants.AlreadyRated);
}
