public async Task AcceptFriendshipShouldReturnFalseIfOneOfTheUsersDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
await db.Users.AddAsync(firstUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.AcceptFriendshipAsync(firstUser.UserName, "unexistingUser");
// Assert
result
.Should()
.Be(false);
}
public async Task DeleteAlbumShouldReturnTrueIfAlbumExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var album = new Album
{
Id = 1,
Pictures = new List <Picture>()
};
await db.Albums.AddAsync(album);
await db.SaveChangesAsync();
var pictureService = new PictureService(db);
// Act
var result = await pictureService.DeleteAlbumByIdAsync(1);
// Assert
result
.Should()
.Be(true);
var albumExists = await db.Albums.FirstOrDefaultAsync();
albumExists
.Should()
.BeNull();
}
public async Task CreateShouldReturnTrueIfUserExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
await db.Users.AddAsync(firstUser);
await db.SaveChangesAsync();
var postService = new PostService(db);
// Act
var result = await postService.CreateAsync(firstUser.UserName, "Some title", "Some Content");
// Assert
result
.Should()
.Be(true);
var post = await db.Posts.FirstOrDefaultAsync();
post
.Should()
.NotBeNull();
}
public async Task AlbumOwnerIdShouldReturnTheIdOfUserIfAlbumExists()
{
// Arrange
var userId = Guid.NewGuid().ToString();
var db = MockManager.GetMockDatabase();
var user = new User
{
Id = userId
};
var album = new Album
{
Id = 1,
Name = "My album",
User = user
};
await db.Albums.AddAsync(album);
await db.SaveChangesAsync();
var pictureService = new PictureService(db);
// Act
var result = await pictureService.AlbumOwnerId(1);
// Assert
result
.Should()
.NotBeNull()
.And
.Be(userId);
}
public async Task DeletePostShouldReturnTrueIfPostExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var post = new Post
{
Id = 1,
Title = "Title",
Content = "Content"
};
await db.Posts.AddAsync(post);
await db.SaveChangesAsync();
var postService = new PostService(db);
// Act
var result = await postService.DeleteAsync(1);
// Assert
result
.Should()
.Be(true);
var hasPost = await db.Posts.FirstOrDefaultAsync();
hasPost
.Should()
.BeNull();
}
public async Task DeleteMessageShouldReturnTrueIfMessageExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var message = new Message
{
Id = 1
};
await db.Messages.AddAsync(message);
await db.SaveChangesAsync();
var messageService = new MessageService(db);
// Act
var result = await messageService.DeleteMessageAsync(1);
// Assert
result
.Should()
.Be(true);
var messageExists = await db.Messages.FirstOrDefaultAsync();
messageExists
.Should()
.BeNull();
}
public async Task MakeFriendRequestShouldReturnFalseIfOneOfUsersDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
await db.Users.AddAsync(firstUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.MakeFriendRequestAsync(firstUser.UserName, "madeUpUsername");
// Assert
result
.Should()
.Be(false);
var friendship = await db.Friendships.FirstOrDefaultAsync();
friendship
.Should()
.BeNull();
}
public async Task CreateMessageShouldReturnFalseIfOneOfTheUsersDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
await db.Users.AddAsync(firstUser);
await db.SaveChangesAsync();
var messageService = new MessageService(db);
// Act
var result = await messageService.CreateMessageAsync(firstUser.UserName, "unexisting", "Some content");
// Assert
result
.Should()
.Be(false);
var messageExists = await db.Messages.FirstOrDefaultAsync();
messageExists
.Should()
.BeNull();
}
public async Task CreateAlbumShouldReturnTrueIfUserExists()
{
// Arrange
var userId = Guid.NewGuid().ToString();
var db = MockManager.GetMockDatabase();
var user = new User
{
Id = userId
};
await db.Users.AddAsync(user);
await db.SaveChangesAsync();
var pictureService = new PictureService(db);
// Act
var result = await pictureService.CreateAlbumAsync("New album", "New description", user.Id);
// Assert
result
.Should()
.Be(true);
var userAlbum = await db.Albums.FirstOrDefaultAsync();
userAlbum
.Should()
.NotBeNull();
}
public async Task EditShouldSuccessfullyChangeTitleOfExistingPost()
{
// Arrange
var db = MockManager.GetMockDatabase();
var post = new Post
{
Id = 1,
Title = "Title",
Content = "Content"
};
await db.Posts.AddAsync(post);
await db.SaveChangesAsync();
var postService = new PostService(db);
// Act
var result = await postService.EditAsync(1, "New title", "New content");
// Assert
result
.Should()
.Be(true);
var hasPost = await db.Posts.FirstOrDefaultAsync(p => p.Id == post.Id);
hasPost
.Should()
.NotBeNull()
.And
.Match(m => m.As <Post>().Title == "New title");
}
public async Task AlbumOwnerIdShouldReturnNullIfAlbumDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var pictureService = new PictureService(db);
// Act
var result = await pictureService.AlbumOwnerId(1);
// Assert
result
.Should()
.BeNull();
}
public async Task DeleteAccountShouldReturnFalseIfUserDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var userService = new UserService(db);
// Act
var result = await userService.DeleteAccountAsync("unexistingUser");
// Assert
result
.Should()
.Be(false);
}
public async Task DeleteMessageShouldReturnFalseIfMessageDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var messageService = new MessageService(db);
// Act
var result = await messageService.DeleteMessageAsync(1);
// Assert
result
.Should()
.Be(false);
}
public async Task AcceptFriendshipShouldReturnTrueIfBothUsersExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "Blq",
LastName = "Qlb"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var friendship = new Friendship
{
User = firstUser,
Friend = secondUser,
FriendshipIssuerId = firstUser.Id
};
await db.Friendships.AddAsync(friendship);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.AcceptFriendshipAsync(firstUser.UserName, secondUser.UserName);
// Assert
result
.Should()
.Be(true);
}
public async Task MakeFriendRequestShouldMakeARecordInFriendshipTable()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Chloe"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.MakeFriendRequestAsync(firstUser.UserName, secondUser.UserName);
// Assert
result
.Should()
.Be(true);
var friendship = await db.Friendships.FirstOrDefaultAsync();
friendship
.Should()
.NotBeNull();
}
public async Task DeleteAccountShouldReturnTrueIfUserExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "Blq",
LastName = "Qlb"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.DeleteAccountAsync(firstUser.UserName);
// Assert
result
.Should()
.Be(true);
var users = await db.Users.ToListAsync();
users
.Should()
.HaveCount(1, "Because one of the two users in the db was deleted");
}
public async Task CreateMessageShouldReturnTrueIfBothSenderAndReceiverExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Chloe"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var messageService = new MessageService(db);
// Act
var result = await messageService.CreateMessageAsync(firstUser.UserName, secondUser.UserName, "Some content");
// Assert
result
.Should()
.Be(true);
var messageExists = await db.Messages.FirstOrDefaultAsync();
messageExists
.Should()
.NotBeNull();
}
public async Task CreateShouldReturnFalseIfUserDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var postService = new PostService(db);
// Act
var result = await postService.CreateAsync("unexistingUsername", "Some title", "Some Content");
// Assert
result
.Should()
.Be(false);
var post = await db.Posts.FirstOrDefaultAsync();
post
.Should()
.BeNull();
}
public async Task ByUsernameAsyncShouldReturnOneUserWhenUserExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Chloe"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.ByUsernameAsync("testuser");
// Assert
result.UserName
.Should()
.NotBeNullOrEmpty()
.And
.Should()
.Equals("testuser");
}
