private Comment SeedComment(MyAlbumDbContext context)
{
int seedCommentId = new Random().Next(1, 100);
string seed = Guid.NewGuid().ToString();
string seedUserId = Guid.NewGuid().ToString();
int seedPhotoId = new Random().Next(1, 100);
string expectedUserName = string.Format("test_{0}@gmail.com", seed);
Comment seedComment = new Comment()
{
Id = seedCommentId,
Content = seed,
Photo = new Photo()
{
Id = seedPhotoId
},
Author = new User()
{
Id = seedUserId,
UserName = expectedUserName
}
};
context.Comments.Add(seedComment);
context.SaveChanges();
return(seedComment);
}
public async Task DeleteComment()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_DeleteComment_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
UnitOfWork unitOfWork = new UnitOfWork(context);
int seedCommentId = new Random().Next(1, 100);
List <Comment> seedComments = SeedComments(seedCommentId, context).ToList();
CommentRepository commentRepository = new CommentRepository(context);
Comment deletedComment = seedComments[0];
// Assert #1
Assert.Equal(seedComments.Count(), context.Comments.Count());
// Act
commentRepository.Delete(deletedComment);
await unitOfWork.CompleteAsync();
// Assert #2
seedComments.Remove(deletedComment);
Assert.True(seedComments.SequenceEqual(context.Comments));
}
}
private IEnumerable <Comment> SeedReplies(int seedCommentId, MyAlbumDbContext context)
{
string seedUserId = Guid.NewGuid().ToString();
int seedPhotoId = new Random().Next(1, 100);
Photo seedPhoto = new Photo()
{
Id = seedPhotoId
};
string expectedUserName = "******";
User seedUser = new User()
{
Id = seedUserId,
UserName = expectedUserName
};
int numOfReplies = new Random().Next(3, 5);
List <Comment> seedReplies = new List <Comment>(numOfReplies);
for (int i = 1; i <= numOfReplies; i++)
{
Comment seedReply = new Comment()
{
Id = seedCommentId + i,
ParentId = null,
Content = Guid.NewGuid().ToString(),
Photo = seedPhoto,
Author = seedUser
};
context.Comments.Add(seedReply);
seedReplies.Add(seedReply);
}
context.SaveChanges();
return(seedReplies);
}
private IEnumerable <Album> SeedAlbums(MyAlbumDbContext context)
{
string seedUserId = Guid.NewGuid().ToString();
string expectedUserName = "******";
User seedUser = new User()
{
Id = seedUserId,
UserName = expectedUserName
};
int numOfAlbums = new Random().Next(5, 20);
List <Album> seedAlbums = new List <Album>(numOfAlbums);
int seedAlbumId = new Random().Next(1, 100);
for (int i = 1; i <= numOfAlbums; i++)
{
Album seedAlbum = new Album()
{
Id = seedAlbumId + i,
Name = Guid.NewGuid().ToString(),
Author = seedUser
};
context.Albums.Add(seedAlbum);
seedAlbums.Add(seedAlbum);
}
context.SaveChanges();
return(seedAlbums);
}
private IEnumerable <Photo> SeedPhotos_HasLocation(MyAlbumDbContext context)
{
string seedUserId = Guid.NewGuid().ToString();
string expectedUserName = "******";
User seedUser = new User()
{
Id = seedUserId,
UserName = expectedUserName
};
int numOfPhotos = new Random().Next(1, 20);
List <Photo> seedPhotos = new List <Photo>(numOfPhotos);
int seedPhotoId = new Random().Next(1, 100);
for (int i = 1; i <= numOfPhotos; i++)
{
Photo seedPhoto = new Photo()
{
Id = seedPhotoId + i,
Name = Guid.NewGuid().ToString(),
Author = seedUser,
};
if (RandBoolean())
{
seedPhoto.LocLng = seedPhoto.LocLat = seedPhotoId;
seedPhotos.Add(seedPhoto);
}
context.Photos.Add(seedPhoto);
}
context.SaveChanges();
return(seedPhotos);
}
private User SeedUser(MyAlbumDbContext context)
{
string seedUserId = Guid.NewGuid().ToString();
User seedUser = new User()
{
Id = seedUserId,
UserName = string.Format("test_{0}@gmail.com", seedUserId),
FirstName = string.Format("FN_{0}", seedUserId),
LastName = string.Format("LN_{0}", seedUserId),
};
context.Users.Add(seedUser);
context.SaveChanges();
return(seedUser);
}
public async Task GetAlbums()
{
// Arrange
var options = new DbContextOptionsBuilder<MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "AlbumRepository_GetAlbums_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
IEnumerable<Album> seedAlbums = SeedAlbums(context);
AlbumRepository albumRepository = new AlbumRepository(context);
AlbumQuery filter = new AlbumQuery();
// Act
var albums = await albumRepository.GetAlbums(filter);
// Assert
Assert.Equal(seedAlbums, albums);
}
}
public void GetOrAdd_Get()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "UserRepository_GetOrAdd_Get_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
var seedUser = SeedUser(context);
var userRepository = new UserRepository(context);
// Act
var result = userRepository.GetOrAdd(seedUser);
// Assert
Assert.Equal(seedUser, result);
}
}
public void GetByNames()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CategoryRepository_GetByNames_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
var seedCategories = SeedCategories(context);
var categoryRepository = new CategoryRepository(context);
// Act
var result = categoryRepository.GetByNames(seedCategories.Select(c => c.Name));
// Assert
Assert.Equal(seedCategories, result);
}
}
public void GetSelfAndAncestors()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_GetSelfAndAncestors_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
int seedCommentId = new Random().Next(1, 100);
IEnumerable <Comment> seedReplies = SeedSelfAndAncestors(seedCommentId, context);
CommentRepository commentRepository = new CommentRepository(context);
// Act
var replies = commentRepository.GetSelfAndAncestors(seedCommentId);
// Assert
Assert.Equal(seedReplies, replies);
}
}
public void GetReplies_ReturnEmptyWhenNotFound()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_GetReplies_ReturnEmptyWhenNotFound_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
int seedCommentId = new Random().Next(1, 100);
IEnumerable <Comment> seedReplies = SeedReplies(seedCommentId, context);
CommentRepository commentRepository = new CommentRepository(context);
// Act
var replies = commentRepository.GetReplies(seedCommentId + 1);
// Assert
Assert.Empty(replies);
}
}
private IEnumerable <Category> SeedCategories(MyAlbumDbContext context)
{
int numOfCategories = new Random().Next(1, 20);
var seedCategories = new List <Category>();
for (int i = 0; i < numOfCategories; i++)
{
var category = new Category()
{
Id = new Random().Next(i * 20, (i + 1) * 20),
Name = Guid.NewGuid().ToString()
};
seedCategories.Add(category);
context.Category.Add(category);
}
context.SaveChanges();
return(seedCategories);
}
public async Task GetComment()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_GetComment_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
Comment seedComment = SeedComment(context);
CommentRepository commentRepository = new CommentRepository(context);
// Act
Comment result = await commentRepository.GetAsync(seedComment.Id);
// Assert
Assert.Equal(seedComment, result);
}
}
public async Task GetAlbum()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "AlbumRepository_GetAlbum_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
Album seedAlbum = SeedAlbum(context);
AlbumRepository albumRepository = new AlbumRepository(context);
// Act
Album result = await albumRepository.GetAsync(seedAlbum.Id);
// Assert
Assert.Equal(seedAlbum, result);
}
}
public async Task GetPhoto()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "PhotoRepository_GetPhoto_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
Photo seedPhoto = SeedPhoto(context);
PhotoRepository photoRepository = new PhotoRepository(context);
// Act
Photo result = await photoRepository.GetAsync(seedPhoto.Id);
// Assert
Assert.Equal(seedPhoto, result);
}
}
public async Task GetPhotos()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "PhotoRepository_GetPhotos_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
IEnumerable <Photo> seedPhotos = SeedPhotos(context);
PhotoRepository photoRepository = new PhotoRepository(context);
PhotoQuery filter = new PhotoQuery();
// Act
var photos = await photoRepository.GetPhotos(filter);
// Assert
Assert.Equal(seedPhotos, photos);
}
}
public async Task AddComment()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_AddComment_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
UnitOfWork unitOfWork = new UnitOfWork(context);
CommentRepository commentRepository = new CommentRepository(context);
string seed = Guid.NewGuid().ToString();
string seedUserId = Guid.NewGuid().ToString();
int seedPhotoId = new Random().Next(1, 100);
string expectedUserName = string.Format("test_{0}@gmail.com", seed);
Comment originalComment = new Comment()
{
Content = seed,
Photo = new Photo()
{
Id = seedPhotoId
},
Author = new User()
{
Id = seedUserId,
UserName = expectedUserName
}
};
// Act
commentRepository.Add(originalComment);
await unitOfWork.CompleteAsync();
// Assert
Assert.Equal(1, await context.Comments.CountAsync(c => true));
var savedComment = await context.Comments.FirstAsync(c => true);
Assert.NotEqual(0, savedComment.Id);
Assert.Equal(originalComment.Content, savedComment.Content);
Assert.Equal(originalComment.Photo.Id, savedComment.Photo.Id);
Assert.Equal(originalComment.Author.Id, savedComment.Author.Id);
Assert.Equal(originalComment.Author.UserName, savedComment.Author.UserName);
}
}
private Photo SeedPhoto(MyAlbumDbContext context)
{
int seedPhotoId = new Random().Next(1, 100);
string seed = Guid.NewGuid().ToString();
string seedUserId = Guid.NewGuid().ToString();
string expectedUserName = string.Format("test_{0}@gmail.com", seed);
Photo seedPhoto = new Photo()
{
Id = seedPhotoId,
Name = seed,
Author = new User()
{
Id = seedUserId,
UserName = expectedUserName
}
};
context.Photos.Add(seedPhoto);
context.SaveChanges();
return(seedPhoto);
}
private Album SeedAlbum(MyAlbumDbContext context)
{
int seedAlbumId = new Random().Next(1, 100);
string seed = Guid.NewGuid().ToString();
string seedUserId = Guid.NewGuid().ToString();
string expectedUserName = string.Format("test_{0}@gmail.com", seed);
Album seedAlbum = new Album()
{
Id = seedAlbumId,
Name = seed,
Author = new User()
{
Id = seedUserId,
UserName = expectedUserName
}
};
context.Albums.Add(seedAlbum);
context.SaveChanges();
return(seedAlbum);
}
private IEnumerable <Comment> SeedSelfAndAncestors(int seedCommentId, MyAlbumDbContext context)
{
string seedUserId = Guid.NewGuid().ToString();
int seedPhotoId = new Random().Next(1, 100);
Photo seedPhoto = new Photo()
{
Id = seedPhotoId
};
string expectedUserName = "******";
User seedUser = new User()
{
Id = seedUserId,
UserName = expectedUserName
};
int numOfLevels = new Random().Next(1, 20);
List <Comment> seedReplies = new List <Comment>(numOfLevels + 1);
int?parentId = null;
for (int i = numOfLevels; i >= 0; i--)
{
Comment seedReply = new Comment()
{
Id = seedCommentId + i,
ParentId = parentId,
Content = Guid.NewGuid().ToString(),
Photo = seedPhoto,
Author = seedUser
};
context.Comments.Add(seedReply);
seedReplies.Add(seedReply);
parentId = seedReply.Id;
}
context.SaveChanges();
seedReplies.Reverse();
return(seedReplies);
}
public async Task DeleteAll()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "CommentRepository_DeleteAll_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
UnitOfWork unitOfWork = new UnitOfWork(context);
int seedCommentId = new Random().Next(1, 100);
IEnumerable <Comment> seedReplies = SeedReplies(seedCommentId, context);
CommentRepository commentRepository = new CommentRepository(context);
// Assert #1
Assert.Equal(seedReplies.Count(), context.Comments.Count());
// Act
commentRepository.DeleteAll(seedReplies.ToList());
await unitOfWork.CompleteAsync();
// Assert #2
Assert.Equal(0, context.Comments.Count());
}
}
public async Task DeletePhoto()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "PhotoRepository_DeletePhoto_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
IEnumerable <Photo> seedPhotos = SeedPhotos(context);
UnitOfWork unitOfWork = new UnitOfWork(context);
PhotoRepository photoRepository = new PhotoRepository(context);
int count = seedPhotos.Count();
foreach (var photo in seedPhotos)
{
// Act
photoRepository.Delete(photo);
await unitOfWork.CompleteAsync();
// Assert
Assert.Equal(--count, context.Photos.Count());
}
}
}
public async Task DeletePhoto()
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: "AlbumRepository_DeleteAlbum_MyAlbumDatabase")
.Options;
using (var context = new MyAlbumDbContext(options))
{
IEnumerable <Album> seedAlbums = SeedAlbums(context);
UnitOfWork unitOfWork = new UnitOfWork(context);
AlbumRepository albumRepository = new AlbumRepository(context);
int count = seedAlbums.Count();
foreach (var album in seedAlbums)
{
// Act
albumRepository.Delete(album);
await unitOfWork.CompleteAsync();
// Assert
Assert.Equal(--count, context.Albums.Count());
}
}
}
public async Task GetImageDimensions(string filePath, string databaseName, int width, int height)
{
// Arrange
var options = new DbContextOptionsBuilder <MyAlbumDbContext>()
.UseInMemoryDatabase(databaseName: databaseName)
.Options;
using (var context = new MyAlbumDbContext(options))
{
PhotoRepository photoRepository = new PhotoRepository(context);
IFormFile file = null;
if (!string.IsNullOrEmpty(filePath))
{
file = GetFormFile(filePath);
}
// Act
var result = await photoRepository.GetImageDimensions(file);
// Assert
Assert.Equal(width, result.Width);
Assert.Equal(height, result.Height);
}
}
public CommentRepository(MyAlbumDbContext context)
{
this.context = context;
}
public PhotoRepository(MyAlbumDbContext context)
{
this.context = context;
}
public UserRepository(MyAlbumDbContext context)
{
this.context = context;
}
public CategoryRepository(MyAlbumDbContext context)
{
this.context = context;
}
