alexis.drai
/
dice_app
0
0
Fork 0
Code Issues 60 Pull Requests Packages Projects 1 Releases Wiki Activity
Labels Milestones
New Pull Request

finalize-db-ef-player #110

Merged
alexis.drai merged 15 commits from finalize-db-ef-player into main 3 years ago
Conversation 0 Commits 15 Files Changed 12
12 changed files with 1526 additions and 416 deletions
Show Stats Download Patch File Download Diff File

720
Sources/App/Program.cs
Unescape View File

@ -1,335 +1,387 @@
using Data; using Data;
using Data.EF.Players; using Data.EF;
using Model.Dice; using Data.EF.Players;
using Model.Dice.Faces; using Model.Dice;
using Model.Games; using Model.Dice.Faces;
using Model.Players; using Model.Games;
using System; using Model.Players;
using System.Collections.Generic; using System;
using System.Diagnostics; using System.Collections.Generic;
using System.Drawing; using System.Diagnostics;
using System.Linq; using System.Drawing;
using System.Linq;
namespace App
{ namespace App
internal static class Program {
{ internal static class Program
static void Main(string[] args) {
{ static void Main(string[] args)
/* {
* the DB stuff and the Model stuff are completely separate here // MODEL stuff
* ILoader loader = new Stub();
* that will change GameRunner gameRunner;
*/ try
{
// DB stuff gameRunner = loader.LoadApp();
// if you've run the 'dotnet' 'ef' commands, you should have a DB with 1 table, and 4 players in it }
using PlayerDBManager playerDBManager = new(); catch (Exception ex)
{
// we'll add a 5th player from the App Console.WriteLine(ex.Message);
PlayerEntity playerEntity = new Player("Ernesto").ToEntity(); Console.WriteLine(ex.StackTrace);
gameRunner = new(new PlayerManager(), new DieManager(), null);
try }
{
playerDBManager.Add(playerEntity); try
} // what if there's already a player with that name? Exception (see PlayerEntity's annotations) {
catch (ArgumentException ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); } // DB stuff when the app opens
catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Did you make sure that the DATABASE exists?"); } using (DiceAppDbContext db = new())
{
try // Later, we'll use the DiceAppDbContext to get a GameDbRunner
{
IEnumerable<PlayerEntity> allPlayersFromDB = playerDBManager.GetAll(); // get all the players from the DB
IEnumerable<PlayerEntity> entities = db.Players;
foreach (PlayerEntity entity in allPlayersFromDB)
{ Debug.WriteLine("Loading players");
Debug.WriteLine(entity);
} foreach (PlayerEntity entity in entities)
} {
catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Did you make sure that the DATABASE exists?"); } try
{
// persist them as models !
// Model stuff gameRunner.GlobalPlayerManager.Add(entity.ToModel());
ILoader loader = new Stub(); Debug.WriteLine($"{entity.ID} -- {entity.Name}");
GameRunner gameRunner; }
try catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
{ }
gameRunner = loader.LoadApp(); }
} }
catch (Exception ex) catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Couldn't use the database"); }
{
Console.WriteLine(ex.Message); string menuChoice = "nothing";
Console.WriteLine(ex.StackTrace);
gameRunner = new(new PlayerManager(), new DieManager(), null); while (menuChoice != "q")
} {
Console.WriteLine(
string menuChoice = "nothing"; "l... load a game\n" +
"n... start new game\n" +
while (menuChoice != "q") "d... delete a game\n" +
{ "i... see all dice\n" +
Console.WriteLine( "c... create a group of dice\n" +
"l... load a game\n" + "p... see all players\n" +
"n... start new game\n" + "y... create players\n" +
"d... delete a game\n" + "q... QUIT\n" +
"c... create a group of dice\n" + ">"
"q... QUIT\n" + );
">"
); menuChoice = Console.ReadLine();
menuChoice = Console.ReadLine(); switch (menuChoice)
{
switch (menuChoice) case "q":
{ break;
case "q":
break; case "l":
string loadName = ChooseGame(gameRunner);
case "l": if (gameRunner.GetOneByName(loadName) != null)
string loadName = ChooseGame(gameRunner); {
if (gameRunner.GetOneByName(loadName) != null) Play(gameRunner, loadName);
{ }
Play(gameRunner, loadName); break;
}
break; case "n":
case "n": if (!gameRunner.GlobalDieManager.GetAll().Any())
{
if (!gameRunner.GlobalDieManager.GetAll().Any()) Console.WriteLine("make at least one dice group first, then try again");
{ break;
Console.WriteLine("make at least one dice group first, then try again"); }
break; Console.WriteLine("add dice to the game");
} IEnumerable<Die> newGameDice = PrepareDice(gameRunner);
IEnumerable<Die> newGameDice = PrepareDice(gameRunner);
string newGameName;
string newGameName; Console.WriteLine("give this new game a name\n>");
Console.WriteLine("give this new game a name\n>"); newGameName = Console.ReadLine();
newGameName = Console.ReadLine();
PlayerManager playerManager = PreparePlayers(gameRunner); Console.WriteLine("add players to the game");
PlayerManager playerManager = PreparePlayers(gameRunner);
gameRunner.StartNewGame(newGameName, playerManager, newGameDice);
Play(gameRunner, newGameName); gameRunner.StartNewGame(newGameName, playerManager, newGameDice);
Play(gameRunner, newGameName);
break;
break;
case "d":
string deleteName = ChooseGame(gameRunner); case "d":
gameRunner.Remove(gameRunner.GetOneByName(deleteName)); string deleteName = ChooseGame(gameRunner);
break; gameRunner.Remove(gameRunner.GetOneByName(deleteName));
break;
case "c":
string newGroupName; case "c":
Console.WriteLine("give this new dice group a name"); string newGroupName;
newGroupName = Console.ReadLine(); Console.WriteLine("give this new dice group a name");
newGroupName = Console.ReadLine();
List<Die> newGroupDice = new();
string menuChoiceNewDice = ""; List<Die> newGroupDice = new();
while (!(menuChoiceNewDice.Equals("ok") && newGroupDice.Any())) string menuChoiceNewDice = "";
{ while (!(menuChoiceNewDice.Equals("ok") && newGroupDice.Any()))
Die die = null; {
Console.WriteLine("create a die you want to add (at least one), or enter 'ok' if you're finished"); Die die = null;
Console.WriteLine("what type of die ?\n" + Console.WriteLine("create a die you want to add (at least one), or enter 'ok' if you're finished");
"n... number\n" + Console.WriteLine("what type of die ?\n" +
"c... color\n" + "n... number\n" +
"i... image"); "c... color\n" +
menuChoiceNewDice = Console.ReadLine(); "i... image");
switch (menuChoiceNewDice) menuChoiceNewDice = Console.ReadLine();
{ switch (menuChoiceNewDice)
case "n": {
die = MakeNumberDie(); case "n":
break; die = MakeNumberDie();
break;
case "c":
die = MakeColorDie(); case "c":
break; die = MakeColorDie();
break;
case "i":
die = MakeImageDie(); case "i":
break; die = MakeImageDie();
} break;
// almost no checks, this is temporary }
if (die is not null) // almost no checks, this is temporary
{ if (die is not null)
newGroupDice.Add(die); {
} newGroupDice.Add(die);
} }
gameRunner.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(newGroupName, newGroupDice)); }
break; gameRunner.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(newGroupName, newGroupDice));
break;
default:
Console.WriteLine("u wot m8?"); case "p":
break; ShowPlayers(gameRunner);
} break;
}
case "i":
} ShowDice(gameRunner);
break;
private static void Play(GameRunner gameRunner, string name)
{ case "y":
string menuChoicePlay = ""; PreparePlayers(gameRunner);
while (menuChoicePlay != "q") break;
{
Game game = gameRunner.GetOneByName(name); default:
Console.WriteLine($"{game.GetWhoPlaysNow()}'s turn\n" + Console.WriteLine("u wot m8?");
"q... quit\n" + break;
"h... show history\n" + }
"s... save\n" + }
"any other... throw");
menuChoicePlay = Console.ReadLine(); try
switch (menuChoicePlay) {
{ // DB stuff when the app closes
case "q": using (DiceAppDbContext db = new())
break; {
case "h": // get all the players from the app's memory
foreach (Turn turn in game.GetHistory()) IEnumerable<Player> models = gameRunner.GlobalPlayerManager.GetAll();
{
Console.WriteLine(turn); // create a PlayerDbManager (and inject it with the DB)
} PlayerDbManager playerDbManager = new(db);
break;
case "s": Debug.WriteLine("Saving players");
gameRunner.Add(game);
break; foreach (Player model in models)
default: {
GameRunner.PlayGame(game); try // to persist them
Console.WriteLine(game.GetHistory().Last()); { // as entities !
break; PlayerEntity entity = model.ToEntity();
} playerDbManager.Add(entity);
} Debug.WriteLine($"{entity.ID} -- {entity.Name}");
} }
// what if there's already a player with that name? Exception (see PlayerEntity's annotations)
private static string ChooseGame(GameRunner gameRunner) catch (ArgumentException ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
{ }
string name; }
Console.WriteLine("which of these games?\n(choose by name)\n>"); } catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Couldn't use the database"); }
foreach (Game game in gameRunner.GetAll()) }
{
Console.WriteLine(game); private static void Play(GameRunner gameRunner, string name)
} {
name = Console.ReadLine(); string menuChoicePlay = "";
return name; while (menuChoicePlay != "q")
} {
Game game = gameRunner.GetOneByName(name);
private static NumberDie MakeNumberDie() Console.WriteLine($"{game.GetWhoPlaysNow()}'s turn\n" +
{ "q... quit\n" +
NumberDie die; "h... show history\n" +
List<NumberFace> faces = new(); "s... save\n" +
string menuChoiceNewFaces = ""; "any other... throw");
menuChoicePlay = Console.ReadLine();
while (menuChoiceNewFaces != "ok") switch (menuChoicePlay)
{ {
Console.WriteLine("create a face with a number, or enter 'ok' if you're finished"); case "q":
menuChoiceNewFaces = Console.ReadLine(); break;
case "h":
if (!menuChoiceNewFaces.Equals("ok") && int.TryParse(menuChoiceNewFaces, out int num)) foreach (Turn turn in game.GetHistory())
{ {
faces.Add(new(num)); Console.WriteLine(turn);
} }
} break;
case "s":
die = new NumberDie(faces.ToArray()); gameRunner.Add(game);
return die; break;
} default:
GameRunner.PlayGame(game);
private static ColorDie MakeColorDie() Console.WriteLine(game.GetHistory().Last());
{ break;
ColorDie die; }
List<ColorFace> faces = new(); }
string menuChoiceNewFaces = ""; }
while (!menuChoiceNewFaces.Equals("ok")) private static string ChooseGame(GameRunner gameRunner)
{ {
Console.WriteLine("create a face with an color name, or enter 'ok' if you're finished"); string name;
menuChoiceNewFaces = Console.ReadLine(); Console.WriteLine("which of these games?\n(choose by name)\n>");
if (menuChoiceNewFaces != "ok") faces.Add(new(Color.FromName(menuChoiceNewFaces))); foreach (Game game in gameRunner.GetAll())
} {
Console.WriteLine(game);
die = new ColorDie(faces.ToArray()); }
return die; name = Console.ReadLine();
} return name;
}
private static ImageDie MakeImageDie()
{ private static void ShowPlayers(GameRunner gameRunner)
ImageDie die; {
List<ImageFace> faces = new(); Console.WriteLine("Look at all them players!");
string menuChoiceNewFaces = ""; foreach (Player player in gameRunner.GlobalPlayerManager.GetAll())
{
while (!menuChoiceNewFaces.Equals("ok")) Console.WriteLine(player);
{ }
Console.WriteLine("create a face with an image uri, or enter 'ok' if you're finished"); }
menuChoiceNewFaces = Console.ReadLine();
private static void ShowDice(GameRunner gameRunner)
if (menuChoiceNewFaces != "ok") {
{ foreach ((string name, IEnumerable<Die> dice) in gameRunner.GlobalDieManager.GetAll())
try {
{ Console.WriteLine($"{name} -- {dice}");
faces.Add(new(new Uri(menuChoiceNewFaces))); }
} }
catch (ArgumentNullException ex)
{ private static NumberDie MakeNumberDie()
Console.WriteLine(ex.Message); {
} NumberDie die;
catch (UriFormatException ex) List<NumberFace> faces = new();
{ string menuChoiceNewFaces = "";
Console.WriteLine("that URI was not valid");
Console.WriteLine(ex.Message); while (menuChoiceNewFaces != "ok")
} {
} Console.WriteLine("create a face with a number, or enter 'ok' if you're finished");
} menuChoiceNewFaces = Console.ReadLine();
die = new ImageDie(faces.ToArray());
return die; if (!menuChoiceNewFaces.Equals("ok") && int.TryParse(menuChoiceNewFaces, out int num))
} {
faces.Add(new(num));
private static IEnumerable<Die> PrepareDice(GameRunner gameRunner) }
{ }
List<Die> result = new();
Console.WriteLine("add dice to the game"); die = new NumberDie(faces.ToArray());
Console.WriteLine("all known dice or groups of dice:"); return die;
foreach ((string name, IEnumerable<Die> dice) in gameRunner.GlobalDieManager.GetAll()) }
{
Console.WriteLine($"{name} -- {dice}"); private static ColorDie MakeColorDie()
} {
string menuChoiceDice = ""; ColorDie die;
while (!(menuChoiceDice.Equals("ok") && result.Any())) List<ColorFace> faces = new();
{ string menuChoiceNewFaces = "";
Console.WriteLine("write the name of a dice group you want to add (at least one), or 'ok' if you're finished");
menuChoiceDice = Console.ReadLine(); while (!menuChoiceNewFaces.Equals("ok"))
// no checks, this is temporary {
if (!menuChoiceDice.Equals("ok")) Console.WriteLine("create a face with an color name, or enter 'ok' if you're finished");
{ menuChoiceNewFaces = Console.ReadLine();
IEnumerable<Die> chosenDice = gameRunner.GlobalDieManager.GetOneByName(menuChoiceDice).Value; if (menuChoiceNewFaces != "ok") faces.Add(new(Color.FromName(menuChoiceNewFaces)));
foreach (Die die in chosenDice) }
{
result.Add(die); die = new ColorDie(faces.ToArray());
} return die;
} }
}
return result.AsEnumerable(); private static ImageDie MakeImageDie()
} {
private static PlayerManager PreparePlayers(GameRunner gameRunner) ImageDie die;
{ List<ImageFace> faces = new();
PlayerManager result = new(); string menuChoiceNewFaces = "";
Console.WriteLine("add players to the game");
Console.WriteLine("all known players:"); while (!menuChoiceNewFaces.Equals("ok"))
foreach (Player player in gameRunner.GlobalPlayerManager.GetAll()) {
{ Console.WriteLine("create a face with an image uri, or enter 'ok' if you're finished");
Console.WriteLine(player); menuChoiceNewFaces = Console.ReadLine();
}
string menuChoicePlayers = ""; if (menuChoiceNewFaces != "ok")
while (!(menuChoicePlayers.Equals("ok") && result.GetAll().Any())) {
{ try
Console.WriteLine("write the name of a player you want to add (at least one), or 'ok' if you're finished"); {
menuChoicePlayers = Console.ReadLine(); faces.Add(new(new Uri(menuChoiceNewFaces)));
if (!menuChoicePlayers.Equals("ok")) }
{ catch (ArgumentNullException ex)
Player player = new(menuChoicePlayers); {
if (!gameRunner.GlobalPlayerManager.GetAll().Contains(player)) Console.WriteLine(ex.Message);
{ }
// if the player didn't exist, now it does... this is temporary catch (UriFormatException ex)
gameRunner.GlobalPlayerManager.Add(player); {
} Console.WriteLine("that URI was not valid");
// almost no checks, this is temporary Console.WriteLine(ex.Message);
result.Add(player); }
} }
} }
die = new ImageDie(faces.ToArray());
return result; return die;
} }
}
private static IEnumerable<Die> PrepareDice(GameRunner gameRunner)
{
List<Die> result = new();
Console.WriteLine("all known dice or groups of dice:");
ShowDice(gameRunner);
string menuChoiceDice = "";
while (!(menuChoiceDice.Equals("ok") && result.Any()))
{
Console.WriteLine("write the name of a dice group you want to add (at least one), or 'ok' if you're finished");
menuChoiceDice = Console.ReadLine();
if (!menuChoiceDice.Equals("ok"))
{
IEnumerable<Die> chosenDice = gameRunner.GlobalDieManager.GetOneByName(menuChoiceDice).Value;
foreach (Die die in chosenDice)
{
result.Add(die);
}
}
}
return result.AsEnumerable();
}
private static PlayerManager PreparePlayers(GameRunner gameRunner)
{
PlayerManager result = new();
Console.WriteLine("all known players:");
ShowPlayers(gameRunner);
string menuChoicePlayers = "";
while (!(menuChoicePlayers.Equals("ok") && result.GetAll().Any()))
{
Console.WriteLine("write the name of a player you want to add (at least one), or 'ok' if you're finished");
menuChoicePlayers = Console.ReadLine();
if (!menuChoicePlayers.Equals("ok"))
{
Player player = new(menuChoicePlayers);
if (!gameRunner.GlobalPlayerManager.GetAll().Contains(player))
{
// if the player didn't exist, now it does... this is temporary
gameRunner.GlobalPlayerManager.Add(player);
}
// almost no checks, this is temporary
try
{
result.Add(player);
}
catch (ArgumentException ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
}
}
return result;
}
}
} }

1
Sources/Data/Data.csproj
Unescape View File

@ -3,7 +3,6 @@
<PropertyGroup> <PropertyGroup>
<TargetFramework>net6.0</TargetFramework> <TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings> <ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<StartWorkingDirectory>$(MSBuildProjectDirectory)</StartWorkingDirectory> <StartWorkingDirectory>$(MSBuildProjectDirectory)</StartWorkingDirectory>
</PropertyGroup> </PropertyGroup>

17
Sources/Data/EF/DiceAppDbContext.cs
Unescape View File

@ -1,14 +1,23 @@
using Data.EF.Players; using Data.EF.Players;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Model.Games;
namespace Data.EF namespace Data.EF
{ {
public class DiceAppDbContext : DbContext public class DiceAppDbContext : DbContext, ILoader
{ {
public DbSet<PlayerEntity>? Players { get; set; } public virtual GameRunner LoadApp() { throw new NotImplementedException(); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) public DbSet<PlayerEntity> Players { get; set; }
=> optionsBuilder.UseSqlite("Data Source=EFDice.DiceApp.db");
public DiceAppDbContext() { }
public DiceAppDbContext(DbContextOptions<DiceAppDbContext> options)
: base(options) { }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!optionsBuilder.IsConfigured) optionsBuilder.UseSqlite("Data Source=EFDice.DiceApp.db").EnableSensitiveDataLogging();
}
} }
} }

19
Sources/Data/EF/DiceAppDbContextWithStub.cs
Unescape View File

@ -1,20 +1,29 @@
using Data.EF.Players; using Data.EF.Players;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Model.Games;
using System.Security.Cryptography.X509Certificates;
namespace Data.EF namespace Data.EF
{ {
public class DiceAppDbContextWithStub : DiceAppDbContext public class DiceAppDbContextWithStub : DiceAppDbContext
{ {
public override GameRunner LoadApp() { throw new NotImplementedException(); }
public DiceAppDbContextWithStub() { }
public DiceAppDbContextWithStub(DbContextOptions<DiceAppDbContext> options)
: base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder) protected override void OnModelCreating(ModelBuilder modelBuilder)
{ {
base.OnModelCreating(modelBuilder); base.OnModelCreating(modelBuilder);
modelBuilder.Entity<PlayerEntity>().HasData( modelBuilder.Entity<PlayerEntity>().HasData(
new PlayerEntity { ID = Guid.Parse("e3b42372-0186-484c-9b1c-01618fbfac44"), Name = "Alice" }, new PlayerEntity { ID = Guid.NewGuid(), Name = "Alice" }, // some tests depend on this name
new PlayerEntity { ID = Guid.Parse("73265e15-3c43-45f8-8f5d-d02feaaf7620"), Name = "Bob" }, new PlayerEntity { ID = Guid.NewGuid(), Name = "Bob" }, // some tests depend on this name
new PlayerEntity { ID = Guid.Parse("5198ba9d-44d6-4660-85f9-1843828c6f0d"), Name = "Clyde" }, new PlayerEntity { ID = Guid.NewGuid(), Name = "Clyde" }, // some tests depend on this name
new PlayerEntity { ID = Guid.Parse("386cec27-fd9d-4475-8093-93c8b569bf2e"), Name = "Dahlia" } new PlayerEntity { ID = Guid.NewGuid(), Name = "Dahlia" } // some tests depend on this name
); );
} }
} }
} }

216
Sources/Data/EF/Players/PlayerDBManager.cs
Unescape View File

@ -1,52 +1,164 @@
using Microsoft.EntityFrameworkCore.ChangeTracking; using Microsoft.EntityFrameworkCore;
using Model; using Microsoft.EntityFrameworkCore.ChangeTracking;
using Model;
namespace Data.EF.Players using Model.Players;
{ using System.Runtime.Intrinsics.Arm;
public sealed class PlayerDBManager : IManager<PlayerEntity>, IDisposable
{ namespace Data.EF.Players
private readonly DiceAppDbContext db = new DiceAppDbContextWithStub(); {
public sealed class PlayerDbManager : IManager<PlayerEntity>
public void Dispose() {
{ private readonly DiceAppDbContext db;
db.Dispose();
} public PlayerDbManager(DiceAppDbContext db)
{
public PlayerEntity Add(PlayerEntity toAdd) if (db is null)
{ {
if (db.Players!.Where(entity => entity.Name == toAdd.Name).Any()) throw new ArgumentNullException(nameof(db), "param should not be null");
{ }
throw new ArgumentException("this username is already taken", nameof(toAdd)); this.db = db;
} }
EntityEntry ee = db.Players!.Add(toAdd);
db.SaveChanges(); /// <summary>
return (PlayerEntity)ee.Entity; /// side effect: entity's name is trimmed.
} /// </summary>
/// <param name="entity"></param>
/// <exception cref="ArgumentNullException"></exception>
public IEnumerable<PlayerEntity> GetAll() /// <exception cref="ArgumentException"></exception>
{ private static void CleanPlayerEntity(PlayerEntity entity)
return db.Players!.AsEnumerable(); {
} if (entity is null)
{
public PlayerEntity GetOneByName(string name) throw new ArgumentNullException(nameof(entity), "param should not be null");
{ }
throw new NotImplementedException(); if (string.IsNullOrWhiteSpace(entity.Name))
} {
throw new ArgumentException("Name property should not be null or whitespace", nameof(entity));
public void Remove(PlayerEntity toRemove) }
{ entity.Name = entity.Name.Trim();
throw new NotImplementedException(); }
}
/// <summary>
public PlayerEntity Update(PlayerEntity before, PlayerEntity after) /// adds a non-null PlayerEntity with a valid name to this mgr's context
{ /// </summary>
throw new NotImplementedException(); /// <param name="toAdd">the entity to add</param>
} /// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public PlayerEntity GetOneByID(Guid ID) /// <exception cref="ArgumentException"></exception>
{ public PlayerEntity Add(PlayerEntity toAdd)
throw new NotImplementedException(); {
} CleanPlayerEntity(toAdd);
}
} if (db.Players.Where(entity => entity.Name == toAdd.Name).Any())
{
throw new ArgumentException("this username is already taken", nameof(toAdd));
}
EntityEntry ee = db.Players.Add(toAdd);
db.SaveChanges();
return (PlayerEntity)ee.Entity;
}
public IEnumerable<PlayerEntity> GetAll()
{
return db.Players.AsEnumerable();
}
/// <summary>
/// This will throw an exception if no player with such name exists.
/// If you want to know whether any player with that name exists, call IsPresentByName()
/// </summary>
/// <param name="name"></param>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="InvalidOperationException"></exception>
/// <returns></returns>
public PlayerEntity GetOneByName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Name property should not be null or whitespace", nameof(name));
}
name = name.Trim();
return db.Players.Where(p => p.Name == name).First();
}
public bool IsPresentByName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return false;
}
name = name.Trim();
return db.Players.Where(p => p.Name == name).Any();
}
/// <summary>
/// removes a non-null PlayerEntity with a valid name from this mgr's context
/// </summary>
/// <param name="toRemove">the entity to remove</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void Remove(PlayerEntity toRemove)
{
CleanPlayerEntity(toRemove);
if (IsPresentByID(toRemove.ID))
{
db.Players.Remove(toRemove);
db.SaveChanges();
}
}
/// <summary>
/// updates a non-null PlayerEntity with a valid name in this mgr's context. This cannot update an ID
/// </summary>
/// <param name="before">the entity to update</param>
/// <param name="after">the entity to replace 'before'</param>
/// <returns>the updated entity</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public PlayerEntity Update(PlayerEntity before, PlayerEntity after)
{
PlayerEntity[] args = { before, after };
foreach (PlayerEntity entity in args)
{
CleanPlayerEntity(entity);
}
if (before.ID != after.ID)
{
throw new ArgumentException("ID cannot be updated", nameof(after));
}
string beforeName = before.Name;
before.Name = after.Name;
EntityEntry ee = db.Players.Update(before);
db.SaveChanges();
before.Name = beforeName;
return (PlayerEntity)ee.Entity;
}
/// <summary>
/// This will throw an exception if no player with such ID exists.
/// If you want to know whether any player with that ID exists, call IsPresentByID()
/// </summary>
/// <param name="ID">the ID to look for</param>
/// <returns>PlayerEntity with that ID</returns>
/// <exception cref="InvalidOperationException"></exception>
public PlayerEntity GetOneByID(Guid ID)
{
return db.Players.First(p => p.ID == ID);
}
public bool IsPresentByID(Guid ID)
{
return db.Players.Where(p => p.ID == ID).Any();
}
}
}

164
Sources/Data/EF/Players/PlayerDbManager.cs
Unescape View File

@ -0,0 +1,164 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using Model;
using Model.Players;
using System.Runtime.Intrinsics.Arm;
namespace Data.EF.Players
{
public sealed class PlayerDbManager : IManager<PlayerEntity>
{
private readonly DiceAppDbContext db;
public PlayerDbManager(DiceAppDbContext db)
{
if (db is null)
{
throw new ArgumentNullException(nameof(db), "param should not be null");
}
this.db = db;
}
/// <summary>
/// side effect: entity's name is trimmed.
/// </summary>
/// <param name="entity"></param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
private static void CleanPlayerEntity(PlayerEntity entity)
{
if (entity is null)
{
throw new ArgumentNullException(nameof(entity), "param should not be null");
}
if (string.IsNullOrWhiteSpace(entity.Name))
{
throw new ArgumentException("Name property should not be null or whitespace", nameof(entity));
}
entity.Name = entity.Name.Trim();
}
/// <summary>
/// adds a non-null PlayerEntity with a valid name to this mgr's context
/// </summary>
/// <param name="toAdd">the entity to add</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public PlayerEntity Add(PlayerEntity toAdd)
{
CleanPlayerEntity(toAdd);
if (db.Players.Where(entity => entity.Name == toAdd.Name).Any())
{
throw new ArgumentException("this username is already taken", nameof(toAdd));
}
EntityEntry ee = db.Players.Add(toAdd);
db.SaveChanges();
return (PlayerEntity)ee.Entity;
}
public IEnumerable<PlayerEntity> GetAll()
{
return db.Players.AsEnumerable();
}
/// <summary>
/// This will throw an exception if no player with such name exists.
/// If you want to know whether any player with that name exists, call IsPresentByName()
/// </summary>
/// <param name="name"></param>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="InvalidOperationException"></exception>
/// <returns></returns>
public PlayerEntity GetOneByName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Name property should not be null or whitespace", nameof(name));
}
name = name.Trim();
return db.Players.Where(p => p.Name == name).First();
}
public bool IsPresentByName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return false;
}
name = name.Trim();
return db.Players.Where(p => p.Name == name).Any();
}
/// <summary>
/// removes a non-null PlayerEntity with a valid name from this mgr's context
/// </summary>
/// <param name="toRemove">the entity to remove</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void Remove(PlayerEntity toRemove)
{
CleanPlayerEntity(toRemove);
if (IsPresentByID(toRemove.ID))
{
db.Players.Remove(toRemove);
db.SaveChanges();
}
}
/// <summary>
/// updates a non-null PlayerEntity with a valid name in this mgr's context. This cannot update an ID
/// </summary>
/// <param name="before">the entity to update</param>
/// <param name="after">the entity to replace 'before'</param>
/// <returns>the updated entity</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public PlayerEntity Update(PlayerEntity before, PlayerEntity after)
{
PlayerEntity[] args = { before, after };
foreach (PlayerEntity entity in args)
{
CleanPlayerEntity(entity);
}
if (before.ID != after.ID)
{
throw new ArgumentException("ID cannot be updated", nameof(after));
}
string beforeName = before.Name;
before.Name = after.Name;
EntityEntry ee = db.Players.Update(before);
db.SaveChanges();
before.Name = beforeName;
return (PlayerEntity)ee.Entity;
}
/// <summary>
/// This will throw an exception if no player with such ID exists.
/// If you want to know whether any player with that ID exists, call IsPresentByID()
/// </summary>
/// <param name="ID">the ID to look for</param>
/// <returns>PlayerEntity with that ID</returns>
/// <exception cref="InvalidOperationException"></exception>
public PlayerEntity GetOneByID(Guid ID)
{
return db.Players.First(p => p.ID == ID);
}
public bool IsPresentByID(Guid ID)
{
return db.Players.Where(p => p.ID == ID).Any();
}
}
}

10
Sources/Data/EF/Players/PlayerEntity.cs
Unescape View File

@ -7,9 +7,9 @@ namespace Data.EF.Players
{ {
public Guid ID { get; set; } public Guid ID { get; set; }
public string? Name { get; set; } public string Name { get; set; }
public override bool Equals(object? obj) public override bool Equals(object obj)
{ {
if (obj is not PlayerEntity) if (obj is not PlayerEntity)
{ {
@ -18,9 +18,9 @@ namespace Data.EF.Players
return Equals(obj as PlayerEntity); return Equals(obj as PlayerEntity);
} }
public bool Equals(PlayerEntity? other) public bool Equals(PlayerEntity other)
{ {
return other is not null && this.ID == other!.ID && this.Name == other.Name; return other is not null && this.ID == other.ID && this.Name == other.Name;
} }
public override int GetHashCode() public override int GetHashCode()
@ -28,7 +28,7 @@ namespace Data.EF.Players
return HashCode.Combine(ID, Name); return HashCode.Combine(ID, Name);
} }
public override string? ToString() public override string ToString()
{ {
return $"{ID.ToString().ToUpper()} -- {Name}"; return $"{ID.ToString().ToUpper()} -- {Name}";
} }

2
Sources/Data/Stub.cs
Unescape View File

@ -12,7 +12,7 @@ namespace Data
{ {
GameRunner gr = new(new PlayerManager(), new DieManager()); GameRunner gr = new(new PlayerManager(), new DieManager());
Player player1 = new("Alice"), player2 = new("Bob"), player3 = new("Clyde"); Player player1 = new("Alice(Old Stub)"), player2 = new("Bob(Old Stub)"), player3 = new("Clyde(Old Stub)");
gr.GlobalPlayerManager.Add(player1); gr.GlobalPlayerManager.Add(player1);
gr.GlobalPlayerManager.Add(player2); gr.GlobalPlayerManager.Add(player2);

722
Sources/Tests/Data_UTs/Players/PlayerDbManagerTest.cs
Unescape View File

@ -0,0 +1,722 @@
using Data.EF;
using Data.EF.Players;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using Model.Players;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xunit;
using Xunit.Sdk;
namespace Tests.Data_UTs.Players
{
public class PlayerDbManagerTest
{
private readonly SqliteConnection connection = new("DataSource=:memory:");
private readonly DbContextOptions<DiceAppDbContext> options;
public PlayerDbManagerTest()
{
connection.Open();
options = new DbContextOptionsBuilder<DiceAppDbContext>()
.UseSqlite(connection)
.EnableSensitiveDataLogging()
.Options;
}
[Theory]
[InlineData("Alice")]
[InlineData("Bob")]
[InlineData("Clyde")]
[InlineData("Dahlia")]
public void TestDbStubContainsAll(string name)
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContextWithStub db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
// Assert
Assert.True(mgr.IsPresentByName(name));
}
}
[Fact]
public void TestConstructorWhenGivenContextThenConstructs()
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
// Assert
Assert.Equal(new Collection<PlayerEntity>(), mgr.GetAll());
}
}
[Fact]
public void TestConstructorWhenGivenNullThrowsException()
{
// Arrange
PlayerDbManager mgr;
// Act
void action() => mgr = new PlayerDbManager(null);
// Assert
Assert.Throws<ArgumentNullException>(action);
}
[Fact]
public void TestAddWhenValidThenValid()
{
// Arrange
string expectedName = "Jeff";
int expectedCount = 2;
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new PlayerEntity() { Name = expectedName });
mgr.Add(new PlayerEntity() { Name = "whatever" });
// mgr takes care of the SaveChange() calls internally
// we might use Units of Work later, to optimize our calls to DB
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.Equal(expectedName, mgr.GetOneByName(expectedName).Name);
Assert.Equal(expectedCount, mgr.GetAll().Count());
}
}
[Fact]
public void TestAddWhenPreExistentThenException()
{
// Arrange
string name = "Flynt";
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new PlayerEntity() { Name = name });
void action() => mgr.Add(new PlayerEntity() { Name = name });
// Assert
Assert.Throws<ArgumentException>(action);
}
}
[Fact]
public void TestAddWhenNullThenException()
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
void action() => mgr.Add(null);
// Assert
Assert.Throws<ArgumentNullException>(action);
}
}
[Theory]
[InlineData(" ")]
[InlineData(null)]
[InlineData("")]
public void TestAddWhenInvalidNameThenException(string name)
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
void action() => mgr.Add(new PlayerEntity() { Name = name });
// Assert
Assert.Throws<ArgumentException>(action);
}
}
[Theory]
[InlineData(" ")]
[InlineData(null)]
[InlineData("")]
public void TestGetOneByNameWhenInvalidThenException(string name)
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { Name = "Ernesto" });
mgr.Add(new() { Name = "Basil" });
void action() => mgr.GetOneByName(name);
// Assert
Assert.Throws<ArgumentException>(action);
}
}
[Theory]
[InlineData("Caroline")]
[InlineData("Caroline ")]
[InlineData(" Caroline")]
public void TestGetOneByNameWhenValidAndExistsThenGetsIt(string name)
{
// Arrange
PlayerDbManager mgr;
PlayerEntity actual;
PlayerEntity expected = new() { Name = name.Trim() };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(expected);
mgr.Add(new() { Name = "Philip" });
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
actual = mgr.GetOneByName(name);
Assert.Equal(expected, actual);
}
}
[Fact]
public void TestGetOneByNameWhenValidAndNotExistsThenException()
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
//mgr.Add(expected);
mgr.Add(new() { Name = "Brett" });
mgr.Add(new() { Name = "Noah" });
void action() => mgr.GetOneByName("*r^a*éàru é^à");
// Assert
Assert.Throws<InvalidOperationException>(action);
}
}
[Fact]
public void TestIsPresentByNameWhenValidAndExistsThenTrue()
{
// Arrange
PlayerDbManager mgr;
string name = "Gerald";
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { Name = "Philip" });
mgr.Add(new() { Name = name });
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.True(mgr.IsPresentByName(name));
}
}
[Theory]
[InlineData("")]
[InlineData(" ")]
[InlineData(null)]
[InlineData("Barbara")]
public void TestIsPresentByNameWhenInvalidOrNonExistentThenFalse(string name)
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { Name = "Herman" });
mgr.Add(new() { Name = "Paulo" });
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.False(mgr.IsPresentByName(name));
}
}
[Fact]
public void TestRemoveWhenNullThenException()
{
// Arrange
PlayerDbManager mgr;
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
void action() => mgr.Remove(null);
// Assert
Assert.Throws<ArgumentNullException>(action);
}
}
[Fact]
public void TestRemoveWhenPreExistentThenRemoves()
{
// Arrange
PlayerDbManager mgr;
PlayerEntity toRemove = new() { Name = "Filibert" };
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { Name = "Xavier" });
mgr.Add(toRemove);
}
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Remove(toRemove);
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.DoesNotContain(toRemove, mgr.GetAll());
}
}
[Fact]
public void TestRemoveWhenNonExistentThenStillNonExistent()
{
// Arrange
PlayerDbManager mgr;
PlayerEntity toRemove = new() { Name = "Filibert" };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { Name = "Bert" });
mgr.Remove(toRemove);
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.DoesNotContain(toRemove, mgr.GetAll());
}
}
[Theory]
[InlineData("filiBert")]
[InlineData("Bertrand")]
public void TestUpdateWhenValidThenUpdates(string name)
{
// Arrange
PlayerDbManager mgr;
Guid idBefore = Guid.NewGuid();
PlayerEntity before = new() { ID = idBefore, Name = "Filibert" };
PlayerEntity after = new() { ID = idBefore, Name = name };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(before);
mgr.Update(before, after);
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.DoesNotContain(before, mgr.GetAll());
Assert.Contains(after, mgr.GetAll());
}
}
[Theory]
[InlineData("Valerie")]
[InlineData("Valerie ")]
[InlineData(" Valerie")]
public void TestUpdateWhenSameThenKeepsAndWorks(string name)
{
// Arrange
PlayerDbManager mgr;
string nameBefore = "Valerie";
Guid idBefore = Guid.NewGuid();
PlayerEntity before = new() { ID = idBefore, Name = nameBefore };
PlayerEntity after = new() { ID = idBefore, Name = name };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(before);
mgr.Update(before, after);
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.Contains(before, mgr.GetAll());
Assert.Contains(after, mgr.GetAll());
}
}
[Fact]
public void TestUpdateWhenNewIDThenException()
{
// Arrange
PlayerDbManager mgr;
PlayerEntity before = new() { ID = Guid.NewGuid(), Name = "Nova" };
PlayerEntity after = new() { ID = Guid.NewGuid(), Name = "Jacquie" };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(before);
void action() => mgr.Update(before, after);
// Assert
Assert.Throws<ArgumentException>(action);
}
}
[Theory]
[InlineData("")]
[InlineData(" ")]
[InlineData(null)]
public void TestUpdateWhenInvalidThenException(string name)
{
// Arrange
PlayerDbManager mgr;
Guid id = Guid.NewGuid();
PlayerEntity before = new() { ID = id, Name = "Llanfair­pwll­gwyn­gyll­go­gery­chwyrn­drobwll­llan­tysilio­gogo­goch" };
PlayerEntity after = new() { ID = id, Name = name };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(before);
void action() => mgr.Update(before, after);
// Assert
Assert.Throws<ArgumentException>(action);
}
}
[Fact]
public void TestUpdateWhenNullThenException()
{
// Arrange
PlayerDbManager mgr;
PlayerEntity before = new() { ID = Guid.NewGuid(), Name = "Dwight" };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(before);
void action() => mgr.Update(before, null);
// Assert
Assert.Throws<ArgumentNullException>(action);
}
}
[Fact]
public void TestGetOneByIDWhenExistsThenGetsIt()
{
// Arrange
PlayerDbManager mgr;
Guid id = Guid.NewGuid();
PlayerEntity actual;
PlayerEntity expected = new() { ID = id, Name = "Hugh" };
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(expected);
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
actual = mgr.GetOneByID(id);
Assert.Equal(expected, actual);
}
}
[Fact]
public void TestGetOneByIDWhenNotExistsThenException()
{
// Arrange
PlayerDbManager mgr;
Guid id = Guid.NewGuid();
PlayerEntity expected = new() { ID = id, Name = "Kyle" };
Guid otherId = Guid.NewGuid();
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(expected);
void action() => mgr.GetOneByID(otherId);
// Assert
Assert.Throws<InvalidOperationException>(action);
}
}
[Fact]
public void TestIsPresentbyIdWhenExistsThenTrue()
{
// Arrange
PlayerDbManager mgr;
Guid id = Guid.NewGuid();
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { ID = id, Name = "Bobby" });
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.True(mgr.IsPresentByID(id));
}
}
[Fact]
public void TestIsPresentbyIdWhenExistsThenFalse()
{
// Arrange
PlayerDbManager mgr;
Guid id = Guid.NewGuid();
Guid otherId = Guid.NewGuid();
// Act
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
mgr.Add(new() { ID = id, Name = "Victor" });
}
// Assert
using (DiceAppDbContext db = new(options))
{
db.Database.EnsureCreated();
mgr = new(db);
Assert.False(mgr.IsPresentByID(otherId));
}
}
}
}

38
Sources/Tests/Data_UTs/Players/PlayerEntityTest.cs
Unescape View File

@ -27,7 +27,7 @@ namespace Tests.Data_UTs.Players
{ {
// Arrange // Arrange
PlayerEntity player = new(); PlayerEntity player = new();
Guid expected = new("c8f60957-dd36-4e47-a7ce-1281f4f8bea4"); Guid expected = Guid.NewGuid();
// Act // Act
player.ID = expected; player.ID = expected;
@ -107,10 +107,16 @@ namespace Tests.Data_UTs.Players
PlayerEntity p2; PlayerEntity p2;
PlayerEntity p3; PlayerEntity p3;
Guid id1 = Guid.NewGuid();
Guid id2 = Guid.NewGuid();
string name1 = "Panama";
string name2 = "Clyde";
// Act // Act
p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Panama" }; p1 = new() { ID = id1, Name = name1 };
p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Clyde" }; p2 = new() { ID = id1, Name = name2 };
p3 = new() { ID = new Guid("846d332f-56ca-44fc-8170-6cfd28dab88b"), Name = "Clyde" }; p3 = new() { ID = id2, Name = name2 };
// Assert // Assert
Assert.False(p1.Equals(p2)); Assert.False(p1.Equals(p2));
@ -127,10 +133,12 @@ namespace Tests.Data_UTs.Players
// Arrange // Arrange
PlayerEntity p1; PlayerEntity p1;
PlayerEntity p2; PlayerEntity p2;
Guid id = Guid.NewGuid();
string name = "Marley";
// Act // Act
p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" }; p1 = new() { ID = id, Name = name };
p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" }; p2 = new() { ID = id, Name = name };
// Assert // Assert
Assert.True(p1.Equals(p2)); Assert.True(p1.Equals(p2));
@ -145,10 +153,16 @@ namespace Tests.Data_UTs.Players
PlayerEntity p2; PlayerEntity p2;
PlayerEntity p3; PlayerEntity p3;
Guid id1 = Guid.NewGuid();
Guid id2 = Guid.NewGuid();
string name1 = "Panama";
string name2 = "Clyde";
// Act // Act
p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Panama" }; p1 = new() { ID = id1, Name = name1 };
p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Clyde" }; p2 = new() { ID = id1, Name = name2 };
p3 = new() { ID = new Guid("846d332f-56ca-44fc-8170-6cfd28dab88b"), Name = "Clyde" }; p3 = new() { ID = id2, Name = name2 };
// Assert // Assert
Assert.False(p1.GetHashCode().Equals(p2.GetHashCode())); Assert.False(p1.GetHashCode().Equals(p2.GetHashCode()));
@ -165,10 +179,12 @@ namespace Tests.Data_UTs.Players
// Arrange // Arrange
PlayerEntity p1; PlayerEntity p1;
PlayerEntity p2; PlayerEntity p2;
Guid id = Guid.NewGuid();
string name = "Marley";
// Act // Act
p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" }; p1 = new() { ID = id, Name = name };
p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" }; p2 = new() { ID = id, Name = name };
// Assert // Assert
Assert.True(p1.GetHashCode().Equals(p2.GetHashCode())); Assert.True(p1.GetHashCode().Equals(p2.GetHashCode()));

14
Sources/Tests/Model_UTs/Games/GameRunnerTest.cs
Unescape View File

@ -79,6 +79,20 @@ namespace Tests.Model_UTs.Games
Assert.DoesNotContain(null, stubGameRunner.GetAll()); Assert.DoesNotContain(null, stubGameRunner.GetAll());
} }
[Fact]
public void TestGetOneByIdThrowsException()
{
// Arrange
GameRunner gameRunner = stubGameRunner;
// Act
void action() => gameRunner.GetOneByID(new("62bb72e6-f9fb-442e-a879-e1b70f8f52f3"));
// Assert
Assert.Throws<NotImplementedException>(action);
}
[Theory] [Theory]
[InlineData("")] [InlineData("")]
[InlineData(null)] [InlineData(null)]

19
Sources/Tests/Model_UTs/Players/PlayerManagerTest.cs
Unescape View File

@ -76,6 +76,21 @@ namespace Tests.Model_UTs.Players
Assert.Throws<ArgumentException>(action); Assert.Throws<ArgumentException>(action);
} }
[Fact]
public void TestGetOneByIdThrowsException()
{
// Arrange
PlayerManager playerManager = new();
// Act
void action() => playerManager.GetOneByID(new("1a276327-75fc-45b9-8854-e7c4101088f8"));
// Assert
Assert.Throws<NotImplementedException>(action);
}
[Theory] [Theory]
[InlineData("")] [InlineData("")]
[InlineData(null)] [InlineData(null)]
@ -165,14 +180,12 @@ namespace Tests.Model_UTs.Players
Player player = new("Dylan"); Player player = new("Dylan");
playerManager.Add(player); playerManager.Add(player);
Player notPlayer = new("Eric"); Player notPlayer = new("Eric");
IEnumerable<Player> expected = new Collection<Player> { player };
// Act // Act
playerManager.Remove(notPlayer); playerManager.Remove(notPlayer);
IEnumerable<Player> actual = playerManager.GetAll();
// Assert // Assert
Assert.Equal(actual, expected); Assert.DoesNotContain(notPlayer, playerManager.GetAll());
} }
[Fact] [Fact]

Write Preview
Loading…
Cancel
Save