public void EditTrack_ShouldSaveEditedTrack()
{
var options = GetDbOptions("EditTrack_Database");
var dummyTrack = new Track();
using (var context = new RiderDBContext(options))
{
context.Tracks.Add(dummyTrack);
context.SaveChanges();
}
dummyTrack.Name = "Edited";
dummyTrack.Description = "Edited";
dummyTrack.Distance = 10;
dummyTrack.Elevation = 100;
Track actual;
using (var context = new RiderDBContext(options))
{
var tracksService = new TracksService(context);
actual = tracksService.EditTrack(dummyTrack);
}
Assert.Equal("Edited", actual.Name);
Assert.Equal("Edited", actual.Description);
Assert.Equal(10, dummyTrack.Distance);
Assert.Equal(100, dummyTrack.Elevation);
}
public void GetMostPopular_ShouldReturnTrackWithMostAttempts()
{
var options = GetDbOptions("GetMostPopular_Database");
var dummyAttempt1 = new Attempt();
var dummyAttempt2 = new Attempt();
var dummyAttempt3 = new Attempt();
var dummyTrack1 = new Track();
var dummyTrack2 = new Track();
dummyTrack1.Attempts.Add(dummyAttempt1);
dummyTrack1.Attempts.Add(dummyAttempt2);
dummyTrack2.Attempts.Add(dummyAttempt3);
using (var context = new RiderDBContext(options))
{
context.Tracks.Add(dummyTrack1);
context.Tracks.Add(dummyTrack2);
context.SaveChanges();
}
Track actual;
using (var context = new RiderDBContext(options))
{
var tracksService = new TracksService(context);
actual = tracksService.GetMostPopular();
}
Assert.Equal(2, actual.Attempts.Count());
Assert.Contains(actual.Attempts, x => x.Id == dummyAttempt1.Id);
Assert.Contains(actual.Attempts, x => x.Id == dummyAttempt2.Id);
}
public void EditPart_ShouldSaveNewPartCorrectly()
{
var options = GetDbOptions("EditPart_Database");
var dummyPart = new Part()
{
Make = "Dummy", Model = "Part"
};
using (var context = new RiderDBContext(options))
{
context.Parts.Add(dummyPart);
context.SaveChanges();
}
Assert.Equal("Part", dummyPart.Model);
Assert.Equal("Dummy", dummyPart.Make);
dummyPart.Make = "Edited Make";
dummyPart.Model = "Edited Model";
Part actual;
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.EditPart(dummyPart);
}
Assert.Equal("Edited Model", actual.Model);
Assert.Equal("Edited Make", actual.Make);
}
public void GetAllTracks_ShouldReturnAllTracks()
{
var options = GetDbOptions("GetAllTracks_Database");
var dummyTrack1 = new Track();
var dummyTrack2 = new Track();
var dummyTrack3 = new Track();
using (var context = new RiderDBContext(options))
{
context.Tracks.Add(dummyTrack1);
context.Tracks.Add(dummyTrack2);
context.Tracks.Add(dummyTrack3);
context.SaveChanges();
}
List <Track> actual;
using (var context = new RiderDBContext(options))
{
var tracksService = new TracksService(context);
actual = tracksService.GetAllTracks().ToList();
}
Assert.Equal(3, actual.Count);
Assert.Contains(actual, x => x.Id == dummyTrack1.Id);
Assert.Contains(actual, x => x.Id == dummyTrack3.Id);
Assert.Contains(actual, x => x.Id == dummyTrack2.Id);
}
public void RemovePartFromInventory_ShouldRemoveCorrectPlayerPart()
{
var options = GetDbOptions("_Database");
var dummyPlayerPart1 = new PlayerParts()
{
Id = 1
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 2
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.SaveChanges();
}
var actual = new List <PlayerParts>();
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
playersService.RemovePartFromInventory(2);
actual = context.PlayerParts.ToList();
}
Assert.Single(actual);
Assert.Contains(actual, x => x.Id == 1);
Assert.DoesNotContain(actual, x => x.Id == 2);
}
public void AddTokens_ShouldAddTokenWhenCorrectDataGiven(string playerId, decimal amount, bool expected)
{
var options = GetDbOptions(string.Format("AddTokens_{0}_{1}_Database", playerId, amount));
var dummyPlayer = new Player()
{
Id = "dummyId", Balance = 0
};
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer);
context.SaveChanges();
}
Player actual;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
playersService.AddTokens(playerId, amount);
actual = context.Users.FirstOrDefault(x => x.Id == dummyPlayer.Id);
}
Assert.Equal(expected, actual.Balance == amount);
}
public void AddPartToInventory_ShouldAddPlayerPart()
{
var options = GetDbOptions("AddPartToInventory_Database");
var dummyPlayer = new Player();
var dummyPart = new Part();
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer);
context.Parts.Add(dummyPart);
context.SaveChanges();
}
PlayerParts actual;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.AddPartToInventory(dummyPart.Id, dummyPlayer.Id);
}
Assert.NotNull(actual);
Assert.Equal(dummyPlayer.Id, actual.PlayerId);
Assert.Equal(dummyPart.Id, actual.PartId);
}
public void GetPlayerPartById_ShouldReturnCorrectPlayerPart()
{
var options = GetDbOptions("GetPlayerPartById_Database");
var dummyPlayerPart1 = new PlayerParts()
{
Id = 123
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 321
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.SaveChanges();
}
PlayerParts actual;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetPlayerPartById(123);
Assert.Equal(123, actual.Id);
actual = playersService.GetPlayerPartById(321);
Assert.Equal(321, actual.Id);
}
}
public void GetPlayerByUsername_ShouldReturnCorrectRole()
{
var options = GetDbOptions("GetPlayerByUsername_Database");
var dummyAttempts = new List <Attempt>();
var dummyPlayerParts = new List <PlayerParts>();
var dummyBikes = new List <Bike>();
var dummyPlayer = new Player()
{
UserName = "******", Attempts = dummyAttempts, Inventory = dummyPlayerParts, Bikes = dummyBikes
};
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer);
context.SaveChanges();
}
Player actual = null;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetPlayerByUsername("Dummy");
}
Assert.False(string.IsNullOrEmpty(actual.Id));
Assert.Equal(dummyPlayer.Id, actual.Id);
}
public void RemoveTokens_ShouldRemoveCorrectAmounOfTokens()
{
var options = GetDbOptions("_Database");
var dummyPlayer = new Player()
{
Id = "dummyId", Balance = 100
};
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer);
context.SaveChanges();
}
Player actual;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
playersService.RemoveTokens(dummyPlayer.Id, 50);
actual = context.Users.FirstOrDefault(x => x.Id == dummyPlayer.Id);
}
Assert.NotNull(actual);
Assert.Equal(50, actual.Balance);
}
public void GetAllWares_ShouldRetunAllWares()
{
var options = GetDbOptions("GetAllWares_Database");
var dummyPlayer = new Player();
var dummyPart = new Part();
var dummyPlayerPart = new PlayerParts() { Player = dummyPlayer, Part = dummyPart };
var dummyWares = new List<Ware>() { new Ware() { PlayerPart = dummyPlayerPart }, new Ware() { PlayerPart = dummyPlayerPart } };
using (var context = new RiderDBContext(options))
{
context.Wares.AddRange(dummyWares);
context.SaveChanges();
}
List<Ware> actual;
using (var context = new RiderDBContext(options))
{
var waresService = new WaresService(context);
actual = waresService.GetAllWares().ToList();
}
Assert.Equal(2, actual.Count);
}
public void RemoveAllAtemptsByBikeId_ShouldRemoveCorrectEntries(int input, int expectedResult)
{
var options = GetDbOptions(string.Format("RemoveAllAtemptsByBikeId_{0}_{1}_Database", input, expectedResult));
var attempts = new List <Attempt>()
{
new Attempt {
PlayerBikeId = 5
},
new Attempt {
PlayerBikeId = 10
},
new Attempt {
PlayerBikeId = 5
},
};
using (var context = new RiderDBContext(options))
{
context.Attempts.AddRange(attempts);
context.SaveChanges();
}
int result = 0;
using (var context = new RiderDBContext(options))
{
var attemptsService = new AttemptsService(context);
attemptsService.RemoveAllAtemptsByBikeId(input);
result = context.Attempts.Count();
}
Assert.Equal(expectedResult, result);
}
public void GetWareById_ShouldReturnCorrectWare()
{
var options = GetDbOptions("GetWareById_Database");
var dummyPlayer = new Player();
var dummyPart = new Part();
var dummyPlayerPart = new PlayerParts() { Player = dummyPlayer, Part = dummyPart };
var dummyWare1 = new Ware() { PlayerPart = dummyPlayerPart };
var dummyWare2 = new Ware() { PlayerPart = dummyPlayerPart };
using (var context = new RiderDBContext(options))
{
context.Wares.Add(dummyWare1);
context.Wares.Add(dummyWare2);
context.SaveChanges();
}
Ware actual;
using (var context = new RiderDBContext(options))
{
var waresService = new WaresService(context);
actual = waresService.GetWareById(dummyWare1.Id);
}
Assert.Equal(dummyWare1.Id, actual.Id);
}
public void RemoveWareById_ShouldRemoveCorrectWare()
{
var options = GetDbOptions("RemoveWareById_Database");
var dummyWare1 = new Ware() { Id = 12 };
var dummyWare2 = new Ware() { Id = 23 };
using (var context = new RiderDBContext(options))
{
context.Wares.Add(dummyWare1);
context.Wares.Add(dummyWare2);
context.SaveChanges();
}
List<Ware> actual;
using (var context = new RiderDBContext(options))
{
var waresService = new WaresService(context);
waresService.RemoveWareById(23);
actual = context.Wares.ToList();
}
Assert.Single(actual);
Assert.Contains(actual, x => x.Id == 12);
Assert.DoesNotContain(actual, x => x.Id == 23);
}
public void GetAllAttemptsCount_ReturnsCorrectAttemptCount()
{
var options = GetDbOptions("GetAllAttemptsCoun_Database");
var attempts = new List <Attempt>()
{
new Attempt(),
new Attempt(),
};
using (var context = new RiderDBContext(options))
{
context.Attempts.AddRange(attempts);
context.SaveChanges();
}
int result = 0;
using (var context = new RiderDBContext(options))
{
var attemptsService = new AttemptsService(context);
result = attemptsService.GetAllAttemptsCount();
}
Assert.Equal(2, result);
}
public void GetTrackById_ShouldReturnCorrectTrack()
{
var options = GetDbOptions("_Database");
var dummyTrack1 = new Track();
var dummyTrack2 = new Track();
var dummyTrack3 = new Track();
using (var context = new RiderDBContext(options))
{
context.Tracks.Add(dummyTrack1);
context.Tracks.Add(dummyTrack2);
context.Tracks.Add(dummyTrack3);
context.SaveChanges();
}
Track actual;
using (var context = new RiderDBContext(options))
{
var tracksService = new TracksService(context);
actual = tracksService.GetTrackById(dummyTrack2.Id);
}
Assert.Equal(dummyTrack2.Id, actual.Id);
}
public void GetPlayerPartByPartId_ShoudlReturnCorrectPlayerParts()
{
var options = GetDbOptions("GetPlayerPartByPartId_Database");
var dummyPlayer = new Player()
{
UserName = "******"
};
var dummyPart1 = new Part()
{
Id = 1
};
var dummyPart2 = new Part()
{
Id = 2
};
var dummyPlayerPart1 = new PlayerParts()
{
Id = 12, Player = dummyPlayer, Part = dummyPart1
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 21, Player = dummyPlayer, Part = dummyPart2
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.SaveChanges();
}
PlayerParts actual;
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPlayerPartByPartId("Dummy", 2);
}
Assert.Equal(21, actual.Id);
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPlayerPartByPartId("Dummy", 1);
}
Assert.Equal(12, actual.Id);
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPlayerPartByPartId("Dummy", 3);
}
Assert.Null(actual);
}
public void GetLatestWare_ShouldReturnLastWareByListedOn()
{
var options = GetDbOptions("GetLatestWare_Database");
var dummyPlayer = new Player();
var dummyPart = new Part();
var dummyPlayerPart = new PlayerParts() { Player = dummyPlayer, Part = dummyPart };
var dummyWare1 = new Ware() { PlayerPart = dummyPlayerPart, ListedOn = DateTime.UtcNow };
var dummyWare2 = new Ware() { PlayerPart = dummyPlayerPart, ListedOn = DateTime.UtcNow };
using (var context = new RiderDBContext(options))
{
context.Wares.Add(dummyWare2);
context.Wares.Add(dummyWare1);
context.SaveChanges();
}
Ware actual;
using (var context = new RiderDBContext(options))
{
var waresService = new WaresService(context);
actual = waresService.GetLatestWare();
}
Assert.Equal(dummyWare2.Id, actual.Id);
}
public void DisusePart_ShouldSetIsUsedFalseAndRemoveBikePartId()
{
var options = GetDbOptions("DisusePart_Database");
var dummyBikePart = new BikeParts();
var dummyPlayerPart1 = new PlayerParts()
{
Id = 10, IsUsed = true, BikePart = dummyBikePart
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 20, IsUsed = true, BikePart = dummyBikePart
};
var dummyPlayerPart3 = new PlayerParts()
{
Id = 30, IsUsed = true, BikePart = dummyBikePart
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.PlayerParts.Add(dummyPlayerPart3);
context.SaveChanges();
}
Assert.True(dummyPlayerPart1.IsUsed);
Assert.True(dummyPlayerPart2.IsUsed);
Assert.NotNull(dummyPlayerPart1.BikePart);
Assert.NotNull(dummyPlayerPart2.BikePart);
PlayerParts actual1;
PlayerParts actual2;
bool isDisused1;
bool isDisused2;
bool isDisused3;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
isDisused1 = playersService.DisusePart(10);
isDisused2 = playersService.DisusePart(20);
isDisused3 = playersService.DisusePart(221);
actual1 = context.PlayerParts.FirstOrDefault(x => x.Id == 10);
actual2 = context.PlayerParts.FirstOrDefault(x => x.Id == 20);
}
Assert.True(isDisused1);
Assert.True(isDisused2);
Assert.False(isDisused3);
Assert.False(actual1.IsUsed);
Assert.False(actual2.IsUsed);
Assert.Null(actual1.BikePart);
Assert.Null(actual2.BikePart);
}
public async Task InvokeAsync(HttpContext context, UserManager <Player> userManager,
RoleManager <IdentityRole> roleManager, RiderDBContext db)
{
SeedRoles(roleManager).GetAwaiter().GetResult();
SeedUserInRoles(userManager).GetAwaiter().GetResult();
await _next(context);
}
public void GetPartById_ShouldReturnCorrectPart()
{
var options = GetDbOptions("GetPartById_Database");
var dummyPart1 = new Part()
{
Id = 2, Make = "dummyMake2", Model = "DummyModel2"
};
var dummyPart2 = new Part()
{
Id = 4, Make = "dummyMake4", Model = "DummyModel4"
};
var dummyPart3 = new Part()
{
Id = 6, Make = "dummyMake6", Model = "DummyModel6"
};
using (var context = new RiderDBContext(options))
{
context.Parts.Add(dummyPart1);
context.Parts.Add(dummyPart2);
context.Parts.Add(dummyPart3);
context.SaveChanges();
}
Part actual;
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPartById(2);
}
Assert.True(actual.Id == 2);
Assert.True(actual.Make == "dummyMake2");
Assert.True(actual.Model == "DummyModel2");
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPartById(6);
}
Assert.True(actual.Id == 6);
Assert.True(actual.Make == "dummyMake6");
Assert.True(actual.Model == "DummyModel6");
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetPartById(22);
}
Assert.True(actual == null);
}
public void GetAllAttemptsByTrackId_ShouldReturnCorrectAttempts()
{
var options = GetDbOptions("GetAllAttemptsByTrackId_Database");
var guidOne = Guid.NewGuid().ToString();
var guidTwo = Guid.NewGuid().ToString();
var trackOne = new Track()
{
Id = guidOne,
};
var trackTwo = new Track()
{
Id = guidTwo,
};
var player = new Player()
{
Id = guidTwo
};
var attempts = new List <Attempt>()
{
new Attempt {
Id = 1, Player = player, Track = trackOne
},
new Attempt {
Id = 2, Player = player, Track = trackOne
},
new Attempt {
Id = 3, Player = player, Track = trackTwo
},
};
using (var context = new RiderDBContext(options))
{
context.Attempts.AddRange(attempts);
context.SaveChanges();
}
var resultAttempts = new List <Attempt>();
using (var context = new RiderDBContext(options))
{
var attemptsService = new AttemptsService(context);
resultAttempts = attemptsService.GetAllAttemptsByTrackId(guidOne).ToList();
}
Assert.Equal(2, resultAttempts.Count());
foreach (var attempt in resultAttempts)
{
Assert.Equal(guidOne, attempt.TrackId);
}
}
public void RemovePartFromSale_ShouldRemovePartFromSale()
{
var options = GetDbOptions("RemovePartFromSale_Database");
var dummyPlayerPart1 = new PlayerParts()
{
Id = 10, IsForSale = true
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 20, IsForSale = true
};
var dummyPlayerPart3 = new PlayerParts()
{
Id = 30, IsForSale = true
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.PlayerParts.Add(dummyPlayerPart3);
context.SaveChanges();
}
Assert.True(dummyPlayerPart1.IsForSale);
Assert.True(dummyPlayerPart2.IsForSale);
PlayerParts actual1;
PlayerParts actual2;
bool isRemoved1;
bool isRemoved2;
bool isRemoved3;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
isRemoved1 = playersService.RemovePartFromSale(10);
isRemoved2 = playersService.RemovePartFromSale(20);
isRemoved3 = playersService.RemovePartFromSale(221);
actual1 = context.PlayerParts.FirstOrDefault(x => x.Id == 10);
actual2 = context.PlayerParts.FirstOrDefault(x => x.Id == 20);
}
Assert.True(isRemoved1);
Assert.True(isRemoved2);
Assert.False(isRemoved3);
Assert.False(actual1.IsForSale);
Assert.False(actual2.IsForSale);
}
public void GetUserBikesByUsername_ShouldReturnCorrectUserBikes()
{
var options = GetDbOptions("GetUserBikesByUsername_Database");
var dummyPlayer1 = new Player()
{
UserName = "******"
};
var dummyPlayer2 = new Player()
{
UserName = "******"
};
var dummyBikeParts = new List <BikeParts>();
var bikes = new List <Bike>
{
new Bike {
Id = 2, Player = dummyPlayer1, BikeParts = dummyBikeParts
},
new Bike {
Id = 3, Player = dummyPlayer1, BikeParts = dummyBikeParts
},
new Bike {
Id = 4, Player = dummyPlayer1, BikeParts = dummyBikeParts
},
new Bike {
Id = 12, Player = dummyPlayer2, BikeParts = dummyBikeParts
},
};
using (var context = new RiderDBContext(options))
{
context.Bikes.AddRange(bikes);
context.SaveChanges();
}
var actualBikes = new List <Bike>();
using (var context = new RiderDBContext(options))
{
var playersService = new Mock <IPlayersService>();
var bikesService = new BikesService(context, playersService.Object);
actualBikes = bikesService.GetUserBikesByUsername(dummyPlayer1.UserName).ToList();
}
Assert.Equal(3, actualBikes.Count());
Assert.Contains(actualBikes, x => x.Id == 2);
Assert.Contains(actualBikes, x => x.Id == 3);
Assert.Contains(actualBikes, x => x.Id == 4);
Assert.DoesNotContain(actualBikes, x => x.Id == 12);
}
public void GetAllPlayers_ShouldReturnAllPlayers()
{
var options = GetDbOptions("GetAllPlayers_Database");
var dummyPlayer1 = new Player()
{
UserName = "******"
};
var dummyPlayer2 = new Player()
{
UserName = "******"
};
var dummyPlayer3 = new Player()
{
UserName = "******"
};
var actual = new List <Player>();
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetAllPlayers().ToList();
}
Assert.Empty(actual);
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer1);
context.Users.Add(dummyPlayer2);
context.Users.Add(dummyPlayer3);
context.SaveChanges();
}
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetAllPlayers().ToList();
}
Assert.Equal(3, actual.Count());
Assert.Contains(actual, x => x.UserName == dummyPlayer1.UserName);
Assert.Contains(actual, x => x.UserName == dummyPlayer2.UserName);
Assert.Contains(actual, x => x.UserName == dummyPlayer3.UserName);
}
public void GetAllParts_ShoudlReturnAllParts()
{
var options = GetDbOptions("GetAllParts_Database");
var actual = new List <Part>();
using (var context = new RiderDBContext(options))
{
var bikesService = new PartsService(context);
actual = bikesService.GetAllParts().ToList();
}
Assert.True(actual.Count() == 0);
var dummyPart1 = new Part()
{
Id = 2
};
var dummyPart2 = new Part()
{
Id = 4
};
var dummyPart3 = new Part()
{
Id = 6
};
using (var context = new RiderDBContext(options))
{
context.Parts.Add(dummyPart1);
context.Parts.Add(dummyPart2);
context.Parts.Add(dummyPart3);
context.SaveChanges();
}
using (var context = new RiderDBContext(options))
{
var partsService = new PartsService(context);
actual = partsService.GetAllParts().ToList();
}
Assert.True(actual.Count() == 3);
Assert.Contains(actual, x => x.Id == 2);
Assert.Contains(actual, x => x.Id == 4);
Assert.Contains(actual, x => x.Id == 6);
}
public void RemoveBikePart_ShouldRemoveCorrectBikePart()
{
var options = GetDbOptions("RemovePartFromBike_Database");
var dummyBikeParts = new List <BikeParts>()
{
new BikeParts()
{
Id = 23
},
new BikeParts()
{
Id = 12
},
new BikeParts()
{
Id = 44
},
new BikeParts()
{
Id = 11
},
};
using (var context = new RiderDBContext(options))
{
context.BikeParts.AddRange(dummyBikeParts);
context.SaveChanges();
}
bool actual;
var actualBikes = new List <BikeParts>();
using (var context = new RiderDBContext(options))
{
var playersService = new Mock <IPlayersService>();
var bikesService = new BikesService(context, playersService.Object);
actual = bikesService.RemoveBikePart(11);
actualBikes = context.BikeParts.ToList();
}
Assert.True(actual);
Assert.DoesNotContain(actualBikes, x => x.Id == 11);
}
public void NicknameTaken_ShouldReturnIfNicknameIsTaken(string nickname, bool expected)
{
var options = GetDbOptions(string.Format("NicknameTaken_{0}_Database", nickname));
var dummyPlayer = new Player()
{
UserName = "******"
};
var dummyBikeParts = new List <BikeParts>();
var bikes = new List <Bike>
{
new Bike {
Nickname = "Taken1", Player = dummyPlayer, BikeParts = dummyBikeParts
},
new Bike {
Nickname = "Taken4", Player = dummyPlayer, BikeParts = dummyBikeParts
},
new Bike {
Nickname = "Taken2", Player = dummyPlayer, BikeParts = dummyBikeParts
},
new Bike {
Nickname = "Taken3", Player = dummyPlayer, BikeParts = dummyBikeParts
},
};
using (var context = new RiderDBContext(options))
{
context.AddRange(bikes);
context.SaveChanges();
}
bool actual;
using (var context = new RiderDBContext(options))
{
var playersService = new Mock <IPlayersService>();
var bikesService = new BikesService(context, playersService.Object);
actual = bikesService.NicknameTaken(nickname, dummyPlayer.UserName);
}
Assert.Equal(expected, actual);
}
public void AddBikeToPlayer_ShouldAddBikeToDatabase()
{
var options = GetDbOptions("AddBikeToPlayer_Database");
var dummyPlayer = new Player()
{
UserName = "******"
};
var dummyBike1 = new Bike();
var dummyBike2 = new Bike();
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer);
context.SaveChanges();
}
using (var context = new RiderDBContext(options))
{
var playersService = new Mock <IPlayersService>();
playersService.Setup(u => u.GetPlayerByUsername(dummyPlayer.UserName))
.Returns(context.Users.FirstOrDefault(x => x.UserName == dummyPlayer.UserName));
var bikesService = new BikesService(context, playersService.Object);
bikesService.AddBikeToPlayer(dummyPlayer.UserName, dummyBike1);
bikesService.AddBikeToPlayer(dummyPlayer.UserName, dummyBike2);
}
Player actual = null;
using (var context = new RiderDBContext(options))
{
actual = context.Users
.Include(x => x.Bikes)
.FirstOrDefault(x => x.UserName == dummyPlayer.UserName);
}
Assert.Equal(2, actual.Bikes.Count());
Assert.Contains(actual.Bikes, x => x.Id == dummyBike1.Id);
Assert.Contains(actual.Bikes, x => x.Id == dummyBike2.Id);
}
public void RemoveBikeById_ShouldRemoveCorrectBike()
{
var options = GetDbOptions("_Database");
const int BikeToRemoveId = 55;
var dummyAttempts = new List <Attempt>();
var dummyPlayer = new Player();
var dummyBikeParts = new List <BikeParts>();
var dummyBikes = new List <Bike>
{
new Bike {
Id = 32, Attempts = dummyAttempts, Player = dummyPlayer, BikeParts = dummyBikeParts
},
new Bike {
Id = BikeToRemoveId, Attempts = dummyAttempts, Player = dummyPlayer, BikeParts = dummyBikeParts
},
new Bike {
Id = 66, Attempts = dummyAttempts, Player = dummyPlayer, BikeParts = dummyBikeParts
},
};
using (var context = new RiderDBContext(options))
{
context.Bikes.AddRange(dummyBikes);
context.SaveChanges();
}
bool actual;
var actualBikes = new List <Bike>();
using (var context = new RiderDBContext(options))
{
var playersService = new Mock <IPlayersService>();
var bikesService = new BikesService(context, playersService.Object);
actual = bikesService.RemoveBikeById(BikeToRemoveId);
actualBikes = context.Bikes.ToList();
}
Assert.True(actual);
Assert.Equal(2, actualBikes.Count());
Assert.DoesNotContain(actualBikes, x => x.Id == BikeToRemoveId);
}
