public async Task DeleteShouldDeleteEntityOfDbSet()
{
var options = new DbContextOptionsBuilder <TimeMachineContext>()
.UseInMemoryDatabase(databaseName: "Get_Last_Tags_Db")
.Options;
var db = new TimeMachineContext(options);
var dbRepository = new DbRepository <Tag>(db);
var tagToDlelete = new Tag();
await dbRepository.AddAsync(tagToDlelete);
await dbRepository.AddAsync(new Tag());
await dbRepository.SaveChangesAsync();
dbRepository.Delete(tagToDlelete);
await dbRepository.SaveChangesAsync();
var entitiesCount = db.Tags.Count();
Assert.Equal(1, entitiesCount);
}
private async Task Setup(DbRepository <Image> imageRepository)
{
this.friend = new User()
{
Id = FRIEND_USER_ID
};
friend.UserFriends.Add(new Friendship()
{
UserId = friend.Id,
FriendId = CURRENT_USER_ID
});
this.unknown = new User()
{
Id = UNKNOWN_USER_ID
};
var friendPublicImage = new Image()
{
Id = 101,
UserId = friend.Id,
User = friend,
IsPublic = true
};
var friendPrivateImage = new Image()
{
Id = 102,
UserId = friend.Id,
User = friend,
IsPublic = true
};
var unknownPublicImage = new Image()
{
Id = 103,
UserId = unknown.Id,
User = unknown,
IsPublic = true
};
var unknownPrivateImage = new Image()
{
Id = 104,
UserId = unknown.Id,
User = unknown,
IsPublic = false
};
await imageRepository.AddAsync(friendPublicImage);
await imageRepository.AddAsync(friendPrivateImage);
await imageRepository.AddAsync(unknownPublicImage);
await imageRepository.AddAsync(unknownPrivateImage);
await imageRepository.SaveChangesAsync();
}
public async Task <GameResult> Handle(CreateGameResultRequest request, CancellationToken cancellationToken)
{
if (request.HomeTeamName == request.GuestTeamName)
{
throw new ArgumentException("Home and guest team name cannot be same");
}
using (var context = _contextFactory.CreateContext())
{
var teamRepository = new DbRepository <Team>(context);
var homeTeam = await teamRepository
.SingleOrDefaultAsync(x => x.Tournament.Name == request.TournamentName &&
x.Name == request.HomeTeamName);
var guestTeam = await teamRepository
.SingleOrDefaultAsync(x => x.Tournament.Name == request.TournamentName &&
x.Name == request.GuestTeamName);
if (homeTeam == null)
{
throw new ArgumentException($"Team with name {request.HomeTeamName} " +
$"doesn't exist in tournament {request.TournamentName}");
}
if (guestTeam == null)
{
throw new ArgumentException($"Team with name {request.GuestTeamName} " +
$"doesn't exist in tournament {request.TournamentName}");
}
var gameRepository = new GameRepository(context);
var game = await gameRepository.GetGame(homeTeam.Id, guestTeam.Id);
var gameResultRepository = new DbRepository <GameResult>(context);
if (game.Result == null)
{
var gameResult = _gameResultFactory.Create(game, request.HomeTeamResult,
request.GuestTeamResult);
await gameResultRepository.AddAsync(gameResult);
return(gameResult);
}
game.Result.GuestTeamResult = request.GuestTeamResult;
game.Result.HomeTeamResult = request.HomeTeamResult;
await gameResultRepository.UpdateAsync(game.Result);
return(game.Result);
}
}
public async Task AllShouldReturnEntitiesCountOfDbSet()
{
var options = new DbContextOptionsBuilder <TimeMachineContext>()
.UseInMemoryDatabase(databaseName: "Get_All_Tags_Db")
.Options;
var db = new TimeMachineContext(options);
var dbRepository = new DbRepository <Tag>(db);
await dbRepository.AddAsync(new Tag());
await dbRepository.AddAsync(new Tag());
await dbRepository.AddAsync(new Tag());
await dbRepository.SaveChangesAsync();
var tagsCount = dbRepository.All().Count();
Assert.Equal(3, tagsCount);
}
public async Task GetLastShouldReturnLastEntitiesOfDbSet()
{
var options = new DbContextOptionsBuilder <TimeMachineContext>()
.UseInMemoryDatabase(databaseName: "Get_Last_Tags_Db")
.Options;
var db = new TimeMachineContext(options);
var dbRepository = new DbRepository <Tag>(db);
await dbRepository.AddAsync(new Tag());
await dbRepository.AddAsync(new Tag());
await dbRepository.AddAsync(new Tag());
await dbRepository.SaveChangesAsync();
var lastEntities = dbRepository.GetLast(1);
var lastEntitiesCount = lastEntities.Count();
Assert.Equal(1, lastEntitiesCount);
}
public async Task AddAsyncShouldAddEntityInDb()
{
var options = new DbContextOptionsBuilder <TimeMachineContext>()
.UseInMemoryDatabase(databaseName: "Save_Tag_Db")
.Options;
var db = new TimeMachineContext(options);
var dbRepository = new DbRepository <Tag>(db);
await dbRepository.AddAsync(new Tag());
await dbRepository.SaveChangesAsync();
var tagsCount = db.Tags.Count();
Assert.Equal(1, tagsCount);
}
public async Task <Tournament> Handle(CreateTournamentRequest request, CancellationToken cancellationToken)
{
using (var context = _contextFactory.CreateContext())
using (var transaction = context.Database.BeginTransaction())
{
var tournament = _tournamentFactory.Create(request.TournamentName, request.TeamsCount);
var tournamentRepository = new DbRepository <Tournament>(context);
await tournamentRepository.AddAsync(tournament);
var rounds = _roundsService.CreateRoundsPerTournament(tournament);
var roundRepository = new DbRepository <Round>(context);
foreach (var round in rounds)
{
await roundRepository.AddAsync(round);
}
transaction.Commit();
return(tournament);
}
}
public ImageServiceTests()
{
//mocks
var options = new DbContextOptionsBuilder <ImageServeDbContext>()
.UseInMemoryDatabase(databaseName: "ImageServeTest") // Give a Unique name to the DB
.Options;
var dbContext = new ImageServeDbContext(options);
var imageRepository = new DbRepository <Image>(dbContext);
var likesRepository = new DbRepository <ImageLike>(dbContext);
var userRepository = new DbRepository <User>(dbContext);
var tagsRepository = new DbRepository <ImageTag>(dbContext);
var mapperMock = new Mock <IMapper>();
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(us => us.GetCurrentId())
.Returns("2")
.Verifiable();
var tagServiceMock = new Mock <ITagService>();
tagServiceMock
.Setup(ts => ts.AddToImageAsync(It.IsAny <Image>()))
.Returns(Task.CompletedTask)
.Verifiable();
var blobServiceMock = new Mock <IBlobStorageService>();
blobServiceMock
.Setup(bs => bs.UploadFromFileAsync(It.IsAny <byte[]>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Verifiable();
//arrange
//AllByUser arrange
this.friend = new User()
{
Id = "2"
};
friend.UserFriends.Add(new Friendship()
{
UserId = friend.Id,
FriendId = "2"
});
this.unknown = new User()
{
Id = "3"
};
var friendPublicImage = new Image()
{
Id = 101,
UserId = friend.Id,
User = friend,
IsPublic = true
};
var friendPrivateImage = new Image()
{
Id = 102,
UserId = friend.Id,
User = friend,
IsPublic = true
};
var unknownPublicImage = new Image()
{
Id = 103,
UserId = unknown.Id,
User = unknown,
IsPublic = true
};
var unknownPrivateImage = new Image()
{
Id = 104,
UserId = unknown.Id,
User = unknown,
IsPublic = false
};
imageRepository.AddAsync(friendPublicImage).GetAwaiter().GetResult();
imageRepository.AddAsync(friendPrivateImage).GetAwaiter().GetResult();
imageRepository.AddAsync(unknownPublicImage).GetAwaiter().GetResult();
imageRepository.AddAsync(unknownPrivateImage).GetAwaiter().GetResult();
imageRepository.SaveChangesAsync().GetAwaiter().GetResult();
imageService = new ImageService(imageRepository, mapperMock.Object, tagServiceMock.Object, userServiceMock.Object, blobServiceMock.Object, likesRepository);
}
