public void CanSendMessage_Should_Return_True()
{
//arrange
var sender = new FanFictionUser
{
Id = "sender",
UserName = "******"
};
var receiver = new FanFictionUser
{
Id = "receiver",
UserName = "******"
};
this.userManager.CreateAsync(receiver).GetAwaiter().GetResult();
this.userManager.CreateAsync(sender).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
string sendername = sender.UserName;
string receivername = receiver.UserName;
var possible = this.messageService.CanSendMessage(sendername, receivername);
//assert
possible.Should().BeTrue();
}
public void MessageSeen_Should_Change_Message_IsReaden_Property_To_True()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var message = new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 1,
Text = "It works?",
};
this.Context.Messages.Add(message);
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
int messageId = message.Id;
this.messageService.MessageSeen(messageId);
//assert
var result = this.Context.Messages.Find(messageId);
result.Should().NotBeNull()
.And.Subject.As <Message>().IsReaden
.Should().BeTrue();
}
public void RegisterUser_Should_Fail_With_Same_Username()
{
//arrange
var toRegister = new RegisterInputModel
{
Nickname = "NewUser",
Password = "******",
ConfirmPassword = "******",
Email = "*****@*****.**",
Username = "******"
};
var user = new FanFictionUser
{
Nickname = "NewUserTwo",
Email = "*****@*****.**",
UserName = "******"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
//act
this.roleService.CreateAsync(new IdentityRole {
Name = GlobalConstants.DefaultRole
}).GetAwaiter();
var result = this.userService.RegisterUser(toRegister).GetAwaiter().GetResult();
//assert
result.Should().BeEquivalentTo(SignInResult.Failed);
}
public void LogUser_Should_Return_Sucess()
{
//arrange
var user = new FanFictionUser
{
UserName = "******",
Nickname = "TestLogin",
};
string userPassword = "******";
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.userManager.AddPasswordAsync(user, userPassword).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
var loginUser = new LoginInputModel
{
Password = userPassword,
Nickname = user.Nickname
};
var result = this.userService.LogUser(loginUser);
//assert
result.Should().BeEquivalentTo(SignInResult.Success);
}
public void UnBlockUser_Should_Throw_Exception()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.SaveChanges();
//act
string userId = user.Id;
string unblockId = userOne.Id;
Action act = () => this.userService.UnblockUser(userId, unblockId);
//assert
act.Should().Throw <InvalidOperationException>()
.WithMessage(GlobalConstants.NoRecordInDb);
}
public void DeleteUser_Should_Throw_Argument_Exception()
{
//arrange
var author = new FanFictionUser
{
Id = "AuthorId",
Nickname = "StoryAuthor",
UserName = "******",
};
var user = new FanFictionUser
{
Id = "userId",
Nickname = "AnotherUser",
UserName = "******",
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(author).GetAwaiter();
this.Context.SaveChanges();
//act
string userToDeleteId = "randomId";
Func <Task> act = async() => await this.adminService.DeleteUser(userToDeleteId);
//assert
act.Should().Throw <ArgumentException>().WithMessage(GlobalConstants.ErrorOnDeleteUser);
}
public void DeleteUser_Should_Delete_User_By_Given_Id()
{
//arrange
var author = new FanFictionUser
{
Id = "AuthorId",
Nickname = "StoryAuthor",
UserName = "******",
};
var user = new FanFictionUser
{
Id = "userId",
Nickname = "AnotherUser",
UserName = "******",
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(author).GetAwaiter();
this.Context.SaveChanges();
//act
string userToDeleteId = author.Id;
this.adminService.DeleteUser(userToDeleteId);
//assert
var users = this.Context.Users.ToList();
users.Should().ContainSingle()
.And.Subject.Should().NotContain(author);
}
public void DeleteComment_Should_Delete_Comment()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var genre = new StoryType
{
Id = 1,
Name = "Fantasy"
};
var story = new FanFictionStory
{
Title = "One",
Id = 1,
CreatedOn = DateTime.Now,
Summary = null,
ImageUrl = GlobalConstants.DefaultNoImage,
Type = genre,
AuthorId = "user"
};
var comment = new Comment
{
StoryId = 1,
FanFictionUser = user,
FanFictionStory = story,
CommentedOn = DateTime.Now.Date,
Message = "SomeComment",
UserId = user.Id,
Id = 1
};
var userManager = (UserManager <FanFictionUser>) this.Provider.GetService(typeof(UserManager <FanFictionUser>));
userManager.CreateAsync(user).GetAwaiter();
this.Context.Comments.Add(comment);
this.Context.StoryTypes.Add(genre);
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
this.CommentService.DeleteComment(1);
var result = this.Context.Comments.ToList();
//assert
result.Should().BeEmpty();
}
public void EditChapter_Should_Edit_Chapter_Content_Or_Title()
{
//arrange
var someUser = new FanFictionUser
{
Id = "AnotherUserId",
Nickname = "ThirdUser",
UserName = "******",
};
var story = new FanFictionStory
{
Id = 1,
Author = someUser,
Summary = "some summary",
Title = "Story To test",
AuthorId = "AnotherUserId",
};
var chapter = new Chapter
{
Id = 1,
Content = "SomeContent",
AuthorId = someUser.Id,
FanFictionUser = someUser,
FanFictionStory = story,
FanFictionStoryId = story.Id,
Title = "Test Chapter",
CreatedOn = DateTime.UtcNow
};
var record = new ChapterEditModel
{
Author = someUser.UserName,
Content = "Some new content",
CreatedOn = chapter.CreatedOn,
Id = chapter.Id,
StoryId = story.Id,
Title = "New Title"
};
userManager.CreateAsync(someUser).GetAwaiter();
this.Context.Chapters.Add(chapter);
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
this.chapterService.EditChapter(record);
//assert
var result = this.Context.Chapters.ProjectTo <ChapterEditModel>().FirstOrDefault(x => x.Id == chapter.Id);
result.Should().NotBeNull().And.Subject.Should().BeEquivalentTo(record);
}
public void AllAnnouncements_Should_Return_Correct_Number_Of_Announcements()
{
//arrange
var user = new FanFictionUser
{
Id = "userId",
Nickname = "AnotherUser",
UserName = "******",
};
var announcements = new[]
{
new Announcement
{
Author = user,
AuthorId = user.Id,
Content = "SomeAnnouncement1",
Id = 1,
PublshedOn = DateTime.Now
},
new Announcement
{
Author = user,
AuthorId = user.Id,
Content = "SomeAnnouncement2",
Id = 2,
PublshedOn = DateTime.Now
},
new Announcement
{
Author = user,
AuthorId = user.Id,
Content = "SomeAnnouncement3",
Id = 3,
PublshedOn = DateTime.Now
},
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.Announcements.AddRange(announcements);
this.Context.SaveChanges();
//act
var result = this.adminService.AllAnnouncements();
//assert
int count = announcements.Length;
result.Announcements.Should()
.NotBeEmpty()
.And.HaveCount(count)
.And.ContainItemsAssignableTo <AnnouncementOutputModel>();
}
public void GetChapterToEditById_Should_Return_The_ChapterEditModel_By_Id()
{
//arrange
var someUser = new FanFictionUser
{
Id = "AnotherUserId",
Nickname = "ThirdUser",
UserName = "******",
};
var story = new FanFictionStory
{
Id = 1,
Author = someUser,
Summary = "some summary",
Title = "Story To test",
AuthorId = "someUserId",
};
var chapter = new Chapter
{
Id = 1,
Content = "SomeContent",
AuthorId = someUser.Id,
FanFictionUser = someUser,
FanFictionStory = story,
FanFictionStoryId = story.Id,
Title = "Test Chapter",
CreatedOn = DateTime.UtcNow
};
var record = new ChapterEditModel
{
Author = someUser.UserName,
Content = chapter.Content,
CreatedOn = chapter.CreatedOn,
Id = chapter.Id,
StoryId = story.Id,
Title = chapter.Title
};
userManager.CreateAsync(someUser).GetAwaiter();
this.Context.Chapters.Add(chapter);
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
int chapterId = chapter.Id;
var result = this.chapterService.GetChapterToEditById(chapterId);
//assert
result.Should().NotBeNull().And.Subject.Should().BeEquivalentTo(record);
}
public void BlockedUsers_Should_Return_Correct_Count()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
var userTwo = new FanFictionUser
{
Nickname = "NewUser3",
Email = "*****@*****.**",
UserName = "******"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.userManager.CreateAsync(userTwo).GetAwaiter();
var blockedPairs = new[]
{
new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne
},
new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userTwo
},
};
this.Context.BlockedUsers.AddRange(blockedPairs);
this.Context.SaveChanges();
//act
int count = blockedPairs.Length;
string userId = user.Id;
var result = this.userService.BlockedUsers(userId);
//assert
result.Should().NotBeNullOrEmpty()
.And.HaveCount(count);
}
public void CreateStory_Should_Work_Correct_With_Null_Iform_File()
{
//arrange
var author = new FanFictionUser
{
Id = "AuthorId",
Nickname = "StoryAuthor",
UserName = "******",
};
var genre = new StoryType
{
Id = 1,
Name = "fantasy"
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
usermanager.CreateAsync(author).GetAwaiter();
this.Context.StoryTypes.Add(genre);
this.Context.SaveChanges();
var newStory = new StoryInputModel
{
Author = author.UserName,
StoryImage = null,
CreatedOn = DateTime.Now,
Genre = "fantasy",
Summary = "someSummary",
Title = "NewStoryTitle",
};
//act
var storyService = GetService();
int result = storyService.CreateStory(newStory).GetAwaiter().GetResult();
var story = this.Context.FictionStories.First();
//assert
result.Should().BePositive().And.Subject.Should().Be(1);
story.Should().NotBeNull().And.Subject.Should().BeEquivalentTo(new
{
Id = 1,
ImageUrl = GlobalConstants.DefaultNoImage,
newStory.Title,
Type = new StoryTypeOutputModel
{
Id = 1,
Type = newStory.Genre
}
}, options => options.ExcludingMissingMembers());
}
public void DeleteStory_Should_Be_Successful_For_Admin()
{
//arrange
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
var author = new FanFictionUser
{
Id = "AuthorId",
Nickname = "StoryAuthor",
UserName = "******",
};
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test",
AuthorId = author.Id,
};
var role = new IdentityRole {
Name = "admin"
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
var roleManager = this.Provider.GetRequiredService <RoleManager <IdentityRole> >();
usermanager.CreateAsync(author).GetAwaiter();
usermanager.CreateAsync(user).GetAwaiter();
roleManager.CreateAsync(role).GetAwaiter();
usermanager.AddToRoleAsync(user, "admin").GetAwaiter();
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
var storyService = GetService();
storyService.DeleteStory(story.Id, user.UserName).GetAwaiter();
//assert
var result = this.Context.FictionStories.FirstOrDefault();
result.Should().BeNull();
}
public void Add_Rating_Should_Throw_Exception_If_AlreadyRated_Is_True()
{
//arrange
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test"
};
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
var rating = new StoryRating
{
Rating = 8,
UserId = user.Id,
Id = 1,
FanFictionUser = user
};
var storyRating = new FanFictionRating
{
FanFictionId = story.Id,
RatingId = rating.Id,
FanFictionStory = story,
StoryRating = rating
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
usermanager.CreateAsync(user).GetAwaiter();
this.Context.FictionStories.Add(story);
this.Context.StoryRatings.Add(rating);
this.Context.FictionRatings.Add(storyRating);
this.Context.SaveChanges();
//act
var storyService = GetService();
Action act = () => storyService.AddRating(story.Id, 1, user.UserName);
//assert
act.Should().Throw <InvalidOperationException>().WithMessage(GlobalConstants.AlreadyRated);
}
public void AddComment_Should_Add_Comment()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var userManager = (UserManager <FanFictionUser>) this.Provider.GetService(typeof(UserManager <FanFictionUser>));
userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
//public int Id { get; set; }
//public int StoryId { get; set; }
//public string Author { get; set; }
//public string Message { get; set; }
//public DateTime CommentedOn { get; set; }
var comment = new CommentInputModel
{
StoryId = 1,
CommentAuthor = "CommentingUser",
CommentedOn = DateTime.Now.Date,
Message = "SomeComment",
};
var commentOut = new CommentOutputModel
{
Id = 1,
Author = "CommentingUser",
CommentedOn = DateTime.Now.Date,
Message = "SomeComment",
StoryId = comment.StoryId
};
//act
this.CommentService.AddComment(comment);
//assert
var result = this.Context.Comments.First();
var mappedResult = Mapper.Map <CommentOutputModel>(result);
mappedResult.Should().BeEquivalentTo(commentOut);
}
private async Task SeedRoles(
UserManager <FanFictionUser> userManager,
RoleManager <IdentityRole> roleManager)
{
await roleManager.CreateAsync(new IdentityRole
{
Name = GlobalConstants.Admin
});
await roleManager.CreateAsync(new IdentityRole
{
Name = GlobalConstants.Moderator
});
await roleManager.CreateAsync(new IdentityRole
{
Name = GlobalConstants.PaidUser
});
await roleManager.CreateAsync(new IdentityRole
{
Name = GlobalConstants.DefaultRole
});
var user = new FanFictionUser
{
UserName = "******",
Email = "*****@*****.**",
Nickname = "ThatAdmin"
};
var normalUser = new FanFictionUser
{
UserName = "******",
Email = "*****@*****.**",
Nickname = "NormalUser"
};
string normalUserPass = "******";
string adminPass = "******";
await userManager.CreateAsync(user, adminPass);
await userManager.CreateAsync(normalUser, normalUserPass);
await userManager.AddToRoleAsync(user, GlobalConstants.Admin);
await userManager.AddToRoleAsync(normalUser, GlobalConstants.DefaultRole);
}
public void All_Message_Seen_Should_Change_For_All_Messages_IsReaden_To_True()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var messages = new[]
{
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 1,
Text = "It works?",
},
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 2,
Text = "It works?two",
}
};
this.Context.Messages.AddRange(messages);
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
string username = user.UserName;
this.messageService.AllMessagesSeen(username);
//assert
var messagesFromDb = this.Context.Messages.Where(x => x.ReceiverId == user.Id).ToArray();
messagesFromDb
.Select(
x => x.IsReaden.Should()
.NotBeFalse())
.Should().HaveCount(2);
}
public void Delete_Message_Should_Delete_Only_The_Message_With_Given_Id()
{
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var messages = new[]
{
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 1,
Text = "It works?",
},
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 2,
Text = "It works?two",
}
};
this.Context.Messages.AddRange(messages);
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
int messageId = messages[0].Id;
this.messageService.DeleteMessage(messageId);
//assert
var messagesFromDb = this.Context.Messages.Where(x => x.ReceiverId == user.Id).ToArray();
int singleMessageIdShouldBe = 2;
messagesFromDb.Should()
.ContainSingle()
.And.Subject.Should()
.Contain(x => x.Id == singleMessageIdShouldBe);
}
public async Task Follow_Should_Create_UserStory_Entity_In_Db()
{
//arrange
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test"
};
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
this.Context.FictionStories.Add(story);
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
await usermanager.CreateAsync(user);
this.Context.SaveChanges();
//act
var storyService = GetService();
var storyId = story.Id;
var username = user.UserName;
var userId = user.Id;
await storyService.Follow(username, userId, storyId);
//assert
var result = this.Context.UsersStories.FirstOrDefault();
var userStory = new UserStory
{
FanfictionUserId = user.Id,
FanFictionStoryId = story.Id
};
result.Should().BeOfType <UserStory>().And.Subject.Should().Equals(userStory);
}
public async Task UnFollow_Should_Remove_UserStoryLink_From_Db()
{
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test"
};
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
var userStory = new UserStory
{
FanfictionUserId = user.Id,
FanFictionStoryId = story.Id
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
await usermanager.CreateAsync(user);
this.Context.FictionStories.Add(story);
this.Context.UsersStories.Add(userStory);
this.Context.SaveChanges();
this.Context.Entry(userStory).State = EntityState.Detached;
//act
var storyService = GetService();
var storyId = story.Id;
var userId = user.Id;
storyService.UnFollow(userId, storyId).GetAwaiter().GetResult();
//assert
var result = this.Context.UsersStories.FirstOrDefault();
result.Should().BeNull();
}
public void ChangeRole_Succeed_Role()
{
//arrange
var roles = new[]
{
"admin",
"superUser",
"moderator",
"user"
};
foreach (var currentRolename in roles)
{
var role = new IdentityRole
{
Name = currentRolename
};
this.roleManager.CreateAsync(role).GetAwaiter();
}
var user = new FanFictionUser
{
Id = "userId",
Nickname = "AnotherUser",
UserName = "******",
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
//act
string newRole = roles[2];
var model = new ChangingRoleModel
{
Id = user.Id,
AppRoles = roles,
NewRole = newRole,
Nickname = user.Nickname,
Role = GlobalConstants.DefaultRole
};
var methodResult = this.adminService.ChangeRole(model);
//assert
methodResult.Should().Equals(IdentityResult.Failed());
}
public async Task Add_Rating_Should_Add_Rating_To_A_Story()
{
//arrange
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test"
};
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
await usermanager.CreateAsync(user);
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
var storyService = GetService();
storyService.AddRating(story.Id, 10, user.UserName);
//assert
var storyRating = new FanFictionRating
{
FanFictionId = 1,
RatingId = 1
};
var result = this.Context.FictionRatings.FirstOrDefault();
result.Should().NotBeNull().And.
Subject.Should()
.BeOfType <FanFictionRating>().And.Should()
.BeEquivalentTo(storyRating, opt => opt.ExcludingMissingMembers());
}
public void Delete_All_Messages_Should_Delete_All_Messages_For_User()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var messages = new[]
{
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 1,
Text = "It works?",
},
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 2,
Text = "It works?two",
}
};
this.Context.Messages.AddRange(messages);
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
string userId = user.Id;
this.messageService.DeleteAllMessages(userId);
//assert
var messagesFromDb = this.Context.Messages.Where(x => x.ReceiverId == user.Id).ToArray();
messagesFromDb.Should().BeEmpty();
}
public void DeleteAllNotifications_Should_Remove_All_Notifications_For_User_By_Username()
{
//arrange
var user = new FanFictionUser
{
Id = "one",
UserName = "******"
};
var notifications = new[]
{
new Notification
{
FanFictionUser = user,
FanFictionUserId = user.Id,
Seen = false,
Message = GlobalConstants.NotificationMessage,
UpdatedStoryId = 1
},
new Notification
{
FanFictionUser = user,
FanFictionUserId = user.Id,
Seen = false,
Message = GlobalConstants.NotificationMessage,
UpdatedStoryId = 2
}
};
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.Notifications.AddRange(notifications);
this.Context.SaveChanges();
//act
string username = user.UserName;
this.notificationService.DeleteAllNotifications(username);
//assert
var userNotifications = this.Context.Notifications.Count();
int expectedCount = 0;
userNotifications.Should().Be(expectedCount);
}
public void DeleteStory_Should_Throw_Exception_With_Admin_And_Author_Bools_False()
{
//arrange
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
var someUser = new FanFictionUser
{
Id = "AnotherUserId",
Nickname = "ThirdUser",
UserName = "******",
};
var story = new FanFictionStory
{
Id = 1,
Author = someUser,
Summary = "some summary",
Title = "Story To test",
AuthorId = "someUserId",
};
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
usermanager.CreateAsync(user).GetAwaiter();
usermanager.CreateAsync(someUser).GetAwaiter();
this.Context.FictionStories.Add(story);
this.Context.SaveChanges();
//act
var storyService = GetService();
Func <Task> act = async() => await storyService.DeleteStory(story.Id, user.UserName);
//assert
act.Should().Throw <OperationCanceledException>();
}
public void BlockUser_Should_Work_Correctly()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.SaveChanges();
//act
string currentUserName = user.UserName;
string toBeBlocked = userOne.UserName;
this.userService.BlockUser(currentUserName, toBeBlocked).GetAwaiter();
//assert
var blockedFromDb = new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne,
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
var blocked = this.Context.BlockedUsers.FirstOrDefault();
blocked.Should().NotBeNull()
.And.Subject.Should().BeEquivalentTo(blockedFromDb);
}
public async Task Follow_Should_Throw_OperationException_When_Try_To_Add_Duplicate_Entity()
{
//arrange
var story = new FanFictionStory
{
Id = 1,
Author = null,
Summary = "some summary",
Title = "Story To test"
};
var user = new FanFictionUser
{
Id = "UserId",
Nickname = "TestStory",
UserName = "******",
};
this.Context.FictionStories.Add(story);
var usermanager = this.Provider.GetRequiredService <UserManager <FanFictionUser> >();
await usermanager.CreateAsync(user);
this.Context.SaveChanges();
//act
var storyService = GetService();
var storyId = story.Id;
var username = user.UserName;
var userId = user.Id;
await storyService.Follow(username, userId, storyId);
//assert
Action act = () => storyService.Follow(username, userId, storyId).GetAwaiter().GetResult();
string message = string.Join(GlobalConstants.UserFollowAlready, user.UserName);
act.Should().Throw <InvalidOperationException>().WithMessage(message);
}
public void NewMessages_Should_Return_The_Count_Of_Messages_Where_Is_Readen_Is_False()
{
//arrange
var user = new FanFictionUser
{
Id = "user",
UserName = "******"
};
var messages = new[]
{
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 1,
Text = "It works?",
},
new Message
{
IsReaden = false,
ReceiverId = user.Id,
Receiver = user,
Id = 2,
Text = "It works?two",
}
};
this.Context.Messages.AddRange(messages);
this.userManager.CreateAsync(user).GetAwaiter().GetResult();
this.Context.SaveChanges();
//act
string userId = user.Id;
int count = this.messageService.NewMessages(userId);
int expectedCount = messages.Count();
//assert
count.Should().BePositive().And.Subject.Should().Be(expectedCount);
}
public void UnBlockUser_Should_Work_Correctly()
{
//arrange
var user = new FanFictionUser
{
Nickname = "NewUser",
Email = "*****@*****.**",
UserName = "******"
};
var userOne = new FanFictionUser
{
Nickname = "NewUser2",
Email = "*****@*****.**",
UserName = "******"
};
var blocked = new BlockedUsers
{
FanFictionUser = user,
BlockedUser = userOne,
FanfictionUserId = user.Id,
BlockedUserId = userOne.Id
};
this.userManager.CreateAsync(user).GetAwaiter();
this.userManager.CreateAsync(userOne).GetAwaiter();
this.Context.BlockedUsers.Add(blocked);
this.Context.SaveChanges();
//act
string userId = user.Id;
string unblockId = userOne.Id;
this.userService.UnblockUser(userId, unblockId);
//assert
var blockedFromDb = this.Context.BlockedUsers;
blockedFromDb.Should().BeNullOrEmpty();
}
