public async Task GetUserByIdAsync_WithValidDAta_ShouldReturnCorrectUser()
{
//Arrange
var expectedUserId = "UserId";
var expectedUsername = "******";
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <ApplicationUser> >();
var userManager = new Mock <UserManager <ApplicationUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var moqGameService = new Mock <IGamesService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.usersService = new UsersService(db, moqHttpContext.Object, userManager.Object, mapper, moqGameService.Object);
var testingUser = new ApplicationUser {
Id = "UserId", UserName = "******"
};
await db.ApplicationUsers.AddAsync(testingUser);
await db.SaveChangesAsync();
//Act
var actual = await this.usersService.GetUserByIdAsync("UserId");
//Assert
Assert.Equal(expectedUserId, actual.Id);
Assert.Equal(expectedUsername, actual.UserName);
}
public async Task DeleteVideoByIdAsync_WithValidData_ShouldReturnTrue()
{
//Arrange
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var testingVideo = new Video
{
Id = 1,
Title = "VideoTitle",
IsDeleted = false
};
await db.Videos.AddRangeAsync(testingVideo);
await db.SaveChangesAsync();
//Act
var actual = await this.videosService.DeleteVideoByIdAsync(1);
//Assert
Assert.True(actual);
Assert.True(testingVideo.IsDeleted);
}
public async Task CreateVideoAsync_WithValidData_VideosInDatabaseShouldReturnCorrectCount()
{
//Arrange
var expectedResult = 1;
var moqPictureService = new Mock <IPicturesService>();
moqPictureService.Setup(x => x.GetPictureByLinkAsync("pictureLink"))
.ReturnsAsync(new Picture
{
Id = 1,
Name = "PictureName",
});
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var inputModel = new AddVideoInputModel
{
VideoTitle = "VideoTitle",
VideoLink = "VideoLink"
};
//Act
await this.videosService.CreateVideoAsync(inputModel);
//Assert
Assert.Equal(expectedResult, db.Videos.ToList().Count);
}
public async Task GetDataPointsForCreatedGamesAsync_WithValidData_ShouldReturnCorrectCountOfDataPoints()
{
//Assert
var expected = 10;
var moqGamesService = new Mock <IGamesService>();
moqGamesService.Setup(x => x.GetTheCountForTheCreatedGamesForTheLastTenDaysAsync())
.ReturnsAsync(new List <int> {
1, 0, 1, 0, 2, 0, 0, 0, 1, 1
});
var moqUsersService = new Mock <IUsersService>();
var moqVideosService = new Mock <IVideosService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
statisticsService = new StatisticsService(moqUsersService.Object, moqGamesService.Object, moqVideosService.Object);
//Act
var actual = await statisticsService.GetDataPointsForCreatedGamesAsync();
//Assert
Assert.Equal(expected, actual.Count());
}
public async Task GetAdministrationIndexStatisticViewModelAsync_WithValidData_ShouldReturnCorrectResult()
{
//Assert
var expectedAllUsersCount = 10;
var expectedAllGamesCount = 5;
var expectedAllVideosCount = 5;
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCountOfAllUsersAsync())
.ReturnsAsync(10);
var moqGamesService = new Mock <IGamesService>();
moqGamesService.Setup(x => x.GetCountOfAllGamesAsync())
.ReturnsAsync(5);
var moqVideosService = new Mock <IVideosService>();
moqVideosService.Setup(x => x.GetCountOfAllVideosAsync())
.ReturnsAsync(5);
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
statisticsService = new StatisticsService(moqUsersService.Object, moqGamesService.Object, moqVideosService.Object);
//Act
var actual = await statisticsService.GetAdministrationIndexStatisticViewModelAsync();
//Assert
Assert.Equal(expectedAllGamesCount, actual.AllGamesCount);
Assert.Equal(expectedAllUsersCount, actual.AllUsersCount);
Assert.Equal(expectedAllVideosCount, actual.AllVideosCount);
}
public async Task GetPictureByLinkAsync_WithValidDAta_ShouldReturnCorrectPicture()
{
//Arrange
var expectedPictureId = 1;
var expectedPictureName = "PictureName";
var expectedPictureLink = "PictureLink";
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.picturesService = new PicturesService(db);
var testingPicture = new Picture
{
Id = 1,
Name = "PictureName",
Link = "PictureLink"
};
await db.Pictures.AddAsync(testingPicture);
await db.SaveChangesAsync();
//Act
var actual = await this.picturesService.GetPictureByLinkAsync("PictureLink");
//Assert
Assert.Equal(expectedPictureId, actual.Id);
Assert.Equal(expectedPictureName, actual.Name);
Assert.Equal(expectedPictureLink, actual.Link);
}
public Form1(ChessDbContext dbContext)
{
InitializeComponent();
InitialView();
ConfigureBoardPanel();
this.dbContext = dbContext;
}
public async Task RemoveFromFavoritesAsync_WithoutVideoInTheFavoritesList_ShouldThrowAndInvalidOperationException()
{
//Arrange
var expectedErrorMessage = "The given video isn't in the favorites list!";
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
var moqUserService = new Mock <IUsersService>();
moqUserService.Setup(x => x.GetCurrentUserAsync())
.ReturnsAsync(new ApplicationUser
{
Id = "UserId",
UserName = "******",
});
favouritesService = new FavouritesService(db, moqUserService.Object);
var testingVideo = new Video
{
Id = 2,
Title = "VideoTitle",
};
await db.Videos.AddAsync(testingVideo);
await db.SaveChangesAsync();
//Act and assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => favouritesService.RemoveFromFavoritesAsync(2));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task AddMoveToDbAsync_WithValidData_ShouldAddMoveToDbCorrectly()
{
//Arrange
var expectedMove = new Move
{
Id = "MoveId",
Title = "MoveTitle",
ApplicationUserId = "UserId",
GameId = "GameId",
};
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserAsync()).ReturnsAsync(new ApplicationUser {
Id = "UserId"
});
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.movesService = new MovesService(db, mapper, moqUsersService.Object);
//Act
await this.movesService.AddMoveToDbAsync("MoveTitle", "GameId");
var resultMove = await db.Moves.FirstOrDefaultAsync(x => x.Title == "MoveTitle" && x.GameId == "GameId");
//Assert
Assert.Equal(expectedMove.Title, resultMove.Title);
Assert.Equal(expectedMove.GameId, resultMove.GameId);
Assert.Equal(expectedMove.ApplicationUserId, resultMove.ApplicationUserId);
}
public VideosService(ChessDbContext db, IPicturesService picturesService, IMapper mapper, IUsersService usersService)
{
this.db = db;
this.picturesService = picturesService;
this.mapper = mapper;
this.usersService = usersService;
}
public async Task UnblockUserByIdAsync_WithValidDAta_ShouldReturnTrue()
{
//Arrange
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <ApplicationUser> >();
var userManager = new Mock <UserManager <ApplicationUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var moqGameService = new Mock <IGamesService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.usersService = new UsersService(db, moqHttpContext.Object, userManager.Object, mapper, moqGameService.Object);
var testingUser = new ApplicationUser
{
Id = "UserId",
UserName = "******",
IsDeleted = true,
EmailConfirmed = true,
CreatedOn = DateTime.UtcNow.AddDays(-25),
};
await db.ApplicationUsers.AddAsync(testingUser);
await db.SaveChangesAsync();
//Act
var actual = await this.usersService.UnblockUserByIdAsync("UserId");
//Assert
Assert.True(actual);
Assert.False(testingUser.IsDeleted);
}
void RemoveExpiredPending(ChessDbContext db)
{
var toRemove = new List <ChessGame>();
foreach (var game in db.Games.AsQueryable().Where(x => x.ApprovalNeeded != ApprovedBy.None && x.ApprovalGiven != x.ApprovalNeeded))
{
var diff = DateTime.Now - game.Timestamp;
if (diff.TotalDays > 3)
{
var emb = new EmbedBuilder();
emb.Title = $"Pending Game Rejected";
emb.Description = $"Game on {game.Timestamp:yyyy/MM/dd hh:mm:ss} was not approved in time, so has been refused";
emb.AddField("P1", game.Winner.Name, true);
emb.AddField("P2", game.Loser.Name, true);
emb.AddField("Draw?", game.Draw ? "Yes" : "No", true);
LogAdmin(emb);
toRemove.Add(game);
}
}
foreach (var x in toRemove)
{
db.Games.Remove(x);
}
if (toRemove.Count > 0)
{
db.SaveChanges();
}
}
public async Task GetFavouriteVideoViewModelsAsync_WithoutAnyVideos_ShouldReturnZeroVideosCount()
{
//Arrange
var expectedResult = 0;
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserAsync())
.ReturnsAsync(new ApplicationUser
{
Id = "UserId",
UserName = "******",
});
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
//Act
var actual = await this.videosService.GetFavouriteVideoViewModelsAsync(1, 10);
//Assert
Assert.Equal(expectedResult, actual.Count);
}
public async Task SeedAsync(ChessDbContext dbContext, IServiceProvider serviceProvider)
{
var roleManager = serviceProvider.GetRequiredService <RoleManager <IdentityRole> >();
var userManager = serviceProvider.GetRequiredService <UserManager <ApplicationUser> >();
await SeedRoleAsync(roleManager, userManager, GlobalConstants.AdministratorRoleName);
}
public UsersService(ChessDbContext context, IHttpContextAccessor contextAccessor, UserManager <ApplicationUser> userManager, IMapper mapper, IGamesService gamesService)
{
this.contextAccessor = contextAccessor;
this.userManager = userManager;
this.mapper = mapper;
this.gamesService = gamesService;
this.context = context;
}
public async Task GetLatestThreeVideosAsync_WithDeletedVideos_ShouldReturnCorrectCount()
{
//Arrange
var expectedResult = 3;
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var testingVideos = new List <Video>
{
new Video {
Id = 1, Title = "Video1", IsDeleted = true, Link = "link1", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 2, Title = "Video2", IsDeleted = false, Link = "link2", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 3, Title = "Video3", IsDeleted = true, Link = "link3", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 4, Title = "Video4", IsDeleted = false, Link = "link4", CreatedOn = DateTime.UtcNow.AddDays(-20), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 5, Title = "Video5", IsDeleted = false, Link = "link5", CreatedOn = DateTime.UtcNow.AddDays(-5), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 6, Title = "Video6", IsDeleted = false, Link = "link6", CreatedOn = DateTime.UtcNow.AddDays(-2), Picture = new Picture {
Link = "PictureLink"
}
},
};
await db.Videos.AddRangeAsync(testingVideos);
await db.SaveChangesAsync();
//Act
var actual = await this.videosService.GetLatestThreeVideosAsync();
//Assert
Assert.Equal(expectedResult, actual.Videos.Count);
}
static void Main()
{
using (ChessDbContext dbContext = new ChessDbContext())
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(dbContext));
}
}
public async Task GetFavouriteVideoViewModelsAsync_WithValidData_ShouldReturnCorrectCountOfFavoriteVideos()
{
//Arrange
var expectedResult = 1;
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserAsync())
.ReturnsAsync(new ApplicationUser
{
Id = "UserId",
UserName = "******",
});
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var userFavouriteVideos = new List <UserFavouriteVideo>
{
new UserFavouriteVideo {
Id = 1, VideoId = 2, ApplicationUserId = "UserId"
},
};
var testingVideos = new List <Video>
{
new Video {
Id = 1, Title = "Video1", IsDeleted = true, Link = "link1", CreatedOn = DateTime.UtcNow.AddDays(-25)
},
new Video {
Id = 2, Title = "Video2", IsDeleted = false, Link = "link2", CreatedOn = DateTime.UtcNow.AddDays(-25), UserFavouriteVideos = userFavouriteVideos
},
new Video {
Id = 3, Title = "Video3", IsDeleted = true, Link = "link3", CreatedOn = DateTime.UtcNow.AddDays(-25)
},
new Video {
Id = 4, Title = "Video4", IsDeleted = false, Link = "link4", CreatedOn = DateTime.UtcNow.AddDays(-20)
},
new Video {
Id = 5, Title = "Video5", IsDeleted = false, Link = "link5", CreatedOn = DateTime.UtcNow.AddDays(-5)
},
};
await db.Videos.AddRangeAsync(testingVideos);
await db.SaveChangesAsync();
//Act
var actual = this.videosService.GetFavouriteVideoViewModelsAsync(1, 10).GetAwaiter().GetResult().ToList();
//Assert
Assert.Equal(expectedResult, actual.Count);
}
public async Task GetAllActiveVideosViewModelsAsync_WithValidData_ShouldReturnCorrectOrder()
{
//Arrange
var expectedResult = new List <int> {
5, 4, 2
};;
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var testingVideos = new List <Video>
{
new Video {
Id = 1, Title = "Video1", IsDeleted = true, Link = "link1", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 2, Title = "Video2", IsDeleted = false, Link = "link2", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 3, Title = "Video3", IsDeleted = true, Link = "link3", CreatedOn = DateTime.UtcNow.AddDays(-25), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 4, Title = "Video4", IsDeleted = false, Link = "link4", CreatedOn = DateTime.UtcNow.AddDays(-20), Picture = new Picture {
Link = "PictureLink"
}
},
new Video {
Id = 5, Title = "Video5", IsDeleted = false, Link = "link5", CreatedOn = DateTime.UtcNow.AddDays(-5), Picture = new Picture {
Link = "PictureLink"
}
},
};
await db.Videos.AddRangeAsync(testingVideos);
await db.SaveChangesAsync();
//Act
var actual = this.videosService.GetAllActiveVideosViewModelsAsync(1, 10).GetAwaiter().GetResult().ToList();
//Assert
Assert.Equal(expectedResult[0], actual[0].Id);
Assert.Equal(expectedResult[1], actual[1].Id);
Assert.Equal(expectedResult[2], actual[2].Id);
}
public List <ChessGame> BuildEntries(ChessPlayer player, ChessDbContext db, DateTime date, bool ignoreOnline)
{
var games = db.GetGamesOnDate(player.Id, date);
if (ignoreOnline)
{
return(games
.Where(x => x.ApprovalNeeded == ApprovedBy.None || x.ApprovalNeeded == ApprovedBy.Moderator)
.ToList());
}
return(games.ToList());
}
void SetConnectedRoles(ChessDbContext db)
{
foreach (var player in db.Players.AsQueryable().Where(x => !x.IsBuiltInAccount).ToList())
{
if (player.ConnectedAccount > 0)
{
var chsServer = Program.ChessGuild.GetUser(player.ConnectedAccount);
if (chsServer != null)
{
if (!player.Removed)
{
chsServer?.AddRoleAsync(ChsPlayer);
}
else
{
chsServer?.RemoveRoleAsync(ChsPlayer);
}
if (player.Permission.HasFlag(ChessPerm.Moderator))
{
chsServer?.AddRoleAsync(ChsMod);
}
else
{
chsServer?.RemoveRoleAsync(ChsMod);
}
if (player.Permission == ChessPerm.Arbiter)
{
chsServer?.AddRoleAsync(ChsArbiter);
}
else
{
chsServer?.RemoveRoleAsync(ChsArbiter);
}
if (player.Permission.HasFlag(ChessPerm.Justice))
{
chsServer?.AddRoleAsync(ChsJustice);
}
else
{
chsServer?.RemoveRoleAsync(ChsJustice);
}
if (player.Permission == ChessPerm.ChiefJustice)
{
chsServer?.AddRoleAsync(ChsChiefJustice);
}
else
{
chsServer?.RemoveRoleAsync(ChsChiefJustice);
}
}
}
}
}
void SendRatingChanges(ChessDbContext db)
{
if (Program.DailyValidateFailed())
{
return;
}
EmbedBuilder builder = new EmbedBuilder();
builder.WithTitle("Leaderboard Changes");
builder.WithColor(Color.Orange);
foreach (var usr in db.Players.AsQueryable().Where(x => !x.IsBuiltInAccount).ToList().OrderByDescending(x => x.Rating))
{
// since this is happening on saturday morning..
var yesturday = DateTime.Now.AddDays(-1);
var score = usr.GetScoreOnDay(yesturday);
int diffb = 0;
int weekBefore = 0;
do
{
diffb -= 7;
weekBefore = usr.GetScoreOnDay(yesturday.AddDays(diffb));
} while (weekBefore == 0 && diffb > -100);
var gamesPlayed = BuildEntries(usr, db, yesturday, false);
if (gamesPlayed.Count > 0 && score > 0)
{ // dont bother adding them if no games were played
if (weekBefore == 0)
{ // never playedd last week
builder.AddField(usr.Name, $"{score}\nN/A Previous");
}
else
{
int diff = score - weekBefore;
if (diff > 0)
{
builder.AddField(usr.Name, $"{score}\n <:small_green_triangle:668750922536452106> {diff}");
}
else if (diff < 0)
{
builder.AddField(usr.Name, $"{score}\n :small_red_triangle_down: {Math.Abs(diff)}");
}
else
{
builder.AddField(usr.Name, $"{score}\n :small_orange_diamond: N/C");
}
}
}
}
if (builder.Fields.Count > 0)
{
LogChnl(builder, GameChannel);
}
}
void setOnlineTokens(ChessDbContext db)
{
foreach (var chs in db.Players.AsQueryable().Where(x => x.DiscordAccount != cast(0)).ToList())
{
var usr = Program.GetUserOrDefault(chs.ConnectedAccount);
if (usr == null)
{
continue;
}
var token = usr.Tokens.FirstOrDefault(x => x.Name == "onlinechesstoken");
if (token != null)
{
chs.VerifyOnlineReference = token.Value;
}
}
}
public async Task GetCountOfAllUsersAsync_WithValidData_ShouldReturnCorrectCount()
{
//Arrange
var expectedResult = 4;
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <ApplicationUser> >();
var userManager = new Mock <UserManager <ApplicationUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var moqGameService = new Mock <IGamesService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.usersService = new UsersService(db, moqHttpContext.Object, userManager.Object, mapper, moqGameService.Object);
var testingUsers = new List <ApplicationUser>
{
new ApplicationUser {
Id = "Id1", UserName = "******", IsDeleted = false, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-25)
},
new ApplicationUser {
Id = "Id2", UserName = "******", IsDeleted = false, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-20)
},
new ApplicationUser {
Id = "Id3", UserName = "******", IsDeleted = false, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-5)
},
new ApplicationUser {
Id = "Id4", UserName = "******", IsDeleted = true, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-5)
},
new ApplicationUser {
Id = "Id5", UserName = "******", IsDeleted = false, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-18)
},
};
await db.ApplicationUsers.AddRangeAsync(testingUsers);
await db.SaveChangesAsync();
//Act
var actual = await this.usersService.GetCountOfAllUsersAsync();
//Assert
Assert.Equal(expectedResult, actual);
}
public async Task AddToFavoritesAsync_WithCurrentUserEqualsToNull_ShouldThrowAndInvalidOperationException()
{
//Arrange
var expectedErrorMessage = "Current user can't be null";
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
var moqUserService = new Mock <IUsersService>();
this.favouritesService = new FavouritesService(db, moqUserService.Object);
//Act and assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => this.favouritesService.AddToFavoritesAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public DateTime getLastPresentDate(ChessDbContext db, ChessPlayer player, bool doLastPlayed = false)
{
if (player.DateLastPresent.HasValue && doLastPlayed == false)
{
return(player.DateLastPresent.Value);
}
DateTime lastPlayed = DateTime.MinValue;
var gamesInvolving = db.GetCurrentGamesWith(player);
foreach (var entry in gamesInvolving)
{
if (entry.Timestamp > lastPlayed)
{
lastPlayed = entry.Timestamp;
}
}
return(lastPlayed);
}
public async Task GetAllBlockedUserViewModelsAsync_WithValidDAta_ShouldReturnCorrectOrder()
{
//Arrange
var expected = new List <string> {
"Id3", "Id2", "Id1"
};
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <ApplicationUser> >();
var userManager = new Mock <UserManager <ApplicationUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var moqGameService = new Mock <IGamesService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.usersService = new UsersService(db, moqHttpContext.Object, userManager.Object, mapper, moqGameService.Object);
var testingUsers = new List <ApplicationUser>
{
new ApplicationUser {
Id = "Id1", UserName = "******", IsDeleted = true, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-25)
},
new ApplicationUser {
Id = "Id2", UserName = "******", IsDeleted = true, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-20)
},
new ApplicationUser {
Id = "Id3", UserName = "******", IsDeleted = true, EmailConfirmed = true, CreatedOn = DateTime.UtcNow.AddDays(-5)
},
};
await db.ApplicationUsers.AddRangeAsync(testingUsers);
await db.SaveChangesAsync();
//Act
var actual = this.usersService.GetAllBlockedUserViewModelsAsync(1, 10).GetAwaiter().GetResult().ToList();
//Assert
Assert.Equal(expected[0], actual[0].Id);
Assert.Equal(expected[1], actual[1].Id);
Assert.Equal(expected[2], actual[2].Id);
}
void CheckLastDatePlayed(ChessDbContext db)
{
if (Program.DailyValidateFailed())
{
return;
}
bool any = false;
foreach (var player in db.Players.AsQueryable().Where(x => !x.IsBuiltInAccount && x.Rating > 100).ToList())
{
var lastPresent = getLastPresentDate(db, player);
var lastPlayed = getLastPresentDate(db, player, true); // will ignore last present.
var presentFridays = FridaysBetween(lastPresent, DateTime.Now);
if (lastPresent == DateTime.MinValue)
{
presentFridays = 0;
}
var playedFridays = FridaysBetween(lastPlayed, DateTime.Now);
if (lastPlayed == DateTime.MinValue)
{
playedFridays = 0;
}
bool sent = false;
if (presentFridays >= 3)
{
sent = true;
setAutomatic(player, -15, $"Not present consc. three weeks (last {lastPresent.ToShortDateString()})");
}
if (playedFridays >= 3)
{
sent = true;
setAutomatic(player, -5, $"Not played consc. three weeks (last {lastPlayed.ToShortDateString()})");
}
any = any || sent;
if (sent)
{
Thread.Sleep(1500);
}
}
if (any)
{
db.SaveChanges();
}
}
public async Task DeleteVideoByIdAsync_WithInvalidVideoId_ShouldThrowArgumentException()
{
//Arrange
var expectedErrorMessage = "Video with the given id doesn't exist!";
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
//Act and assert
var ex = await Assert.ThrowsAsync <ArgumentException>(() => this.videosService.DeleteVideoByIdAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task GetCountOfAllVideosAsync_WithValidData_ShouldReturnCorrectCount()
{
//Arrange
var expectedResult = 5;
var moqPictureService = new Mock <IPicturesService>();
var moqUsersService = new Mock <IUsersService>();
var option = new DbContextOptionsBuilder <ChessDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var db = new ChessDbContext(option);
this.videosService = new VideosService(db, moqPictureService.Object, mapper, moqUsersService.Object);
var testingVideos = new List <Video>
{
new Video {
Id = 1, Title = "Video1", IsDeleted = false, Link = "link1"
},
new Video {
Id = 2, Title = "Video2", IsDeleted = false, Link = "link2"
},
new Video {
Id = 3, Title = "Video3", IsDeleted = false, Link = "link3"
},
new Video {
Id = 4, Title = "Video4", IsDeleted = false, Link = "link4"
},
new Video {
Id = 5, Title = "Video5", IsDeleted = true, Link = "link5"
},
};
await db.Videos.AddRangeAsync(testingVideos);
await db.SaveChangesAsync();
//Act
var actual = await this.videosService.GetCountOfAllVideosAsync();
//Assert
Assert.Equal(expectedResult, actual);
}
