BlazorCICD/BlazorSolution/MiniGamesTests/UnoTest.cs

using MiniGames.Client.ViewModel;
using MiniGames.Shared.Enums;
using MiniGames.Shared.Models;
using System.Collections.Generic;
using System.Linq;
using Xunit;

namespace MiniGamesTests
{
	public class UnoTest
	{
		public Uno UnoRegeln = new();
		public List<SpielerModel> SpielerModels = new();

		private KartenModel BeispielKarte(string name, string farbe, bool spezial)
		{
			var _name = name;
			var _farbe = farbe;
			var _spezial = spezial;

			KartenModel kartenModel = new()
			{
				Name = _name,
				Farbe = _farbe,
				Spezial = _spezial
			};

			return kartenModel;
		}

		private HandKartenModel BeispielHand()
		{
			HandKartenModel HandStapel = new()
			{
				SpielerModel = new()
				{
					Id = 1,
					SpielerName = "Andrej",
				},

				KartenModels = new()
				{
					new KartenModel
					{
						Name = Kartenbezeichnung.PlusZweiKarte.ToString(),
						Farbe = Farbe.Gelb.ToString(),
						Spezial = true
					}
				}
			};

			return HandStapel;
		}

		private void BeispielSpielerModelsFüllen(int id, string spielerName)
		{
			int _id = id;
			string _spielerName = spielerName;

			SpielerModels.Add(new SpielerModel()
			{
				Id = _id,
				SpielerName = _spielerName,
				Punkte = 0
			});
		}

		private void BeispielMultipleSpielerModelsFüllen(int anzahlSpieler)
		{
			switch (anzahlSpieler)
			{
				case 2:
					BeispielSpielerModelsFüllen(1, "Hans");
					BeispielSpielerModelsFüllen(2, "Peter");
					break;
				case 3:
					BeispielSpielerModelsFüllen(1, "Hans");
					BeispielSpielerModelsFüllen(2, "Peter");
					BeispielSpielerModelsFüllen(3, "Anna");
					break;
				case 4:
					BeispielSpielerModelsFüllen(1, "Hans");
					BeispielSpielerModelsFüllen(2, "Peter");
					BeispielSpielerModelsFüllen(3, "Anna");
					BeispielSpielerModelsFüllen(4, "Klaus");
					break;
				case 5:
					BeispielSpielerModelsFüllen(1, "Hans");
					BeispielSpielerModelsFüllen(2, "Peter");
					BeispielSpielerModelsFüllen(3, "Anna");
					BeispielSpielerModelsFüllen(4, "Klaus");
					BeispielSpielerModelsFüllen(5, "Brigitte");
					break;
				case 6:
					BeispielSpielerModelsFüllen(1, "Hans");
					BeispielSpielerModelsFüllen(2, "Peter");
					BeispielSpielerModelsFüllen(3, "Anna");
					BeispielSpielerModelsFüllen(4, "Klaus");
					BeispielSpielerModelsFüllen(5, "Brigitte");
					BeispielSpielerModelsFüllen(6, "Morty");
					break;
				default:
					break;
			}
		}

		private StapelModel BeispielStapelModelKarten(string name, string farbe, bool spezial)
		{
			var _name = name;
			var _farbe = farbe;
			var _spezial = spezial;

			StapelModel TestStapel = new();
			TestStapel.KartenModels = new()
			{
				new KartenModel
				{
					Name = _name,
					Farbe = _farbe,
					Spezial = _spezial
				},
			};
			return TestStapel;
		}

		#region UserManagement
		[Theory]
		[InlineData("Andrej", 1)]
		private void SpielerErstellenTest(string spielerName, int id)
		{
			//arrange
			var _spielerName = spielerName;
			var _id = id;

			//act
			UnoRegeln.SpielerErstellen(_spielerName);
			var ergebnis = UnoRegeln.Spieler;

			//assert
			Assert.Equal(_spielerName, ergebnis[0].SpielerModel.SpielerName);
			Assert.Equal(_id, ergebnis[0].SpielerModel.Id);
		}

		[Theory]
		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3)]
		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3)]
		[InlineData("Thomas", 1, "Mike", 2, "Robin", 3)]
		private void MehrereSpielerErstellenTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId)
		{
			//arrange
			var _spielerEinsName = spielerEinsName;
			var _spielerEinsId = spielerEinsId;
			var _spielerZweiName = spielerZweiName;
			var _spielerZweiId = spielerZweiId;
			var _spielerDreiName = spielerDreiName;
			var _spielerDreiId = spielerDreiId;

			//act
			UnoRegeln.SpielerErstellen(_spielerEinsName);
			UnoRegeln.SpielerErstellen(_spielerZweiName);
			UnoRegeln.SpielerErstellen(_spielerDreiName);
			var ergebnis = UnoRegeln.Spieler;

			//assert
			Assert.Equal(_spielerEinsName, ergebnis[0].SpielerModel.SpielerName);
			Assert.Equal(_spielerEinsId, ergebnis[0].SpielerModel.Id);
			Assert.NotNull(ergebnis[0].KartenModels);

			Assert.Equal(_spielerZweiName, ergebnis[1].SpielerModel.SpielerName);
			Assert.Equal(_spielerZweiId, ergebnis[1].SpielerModel.Id);
			Assert.NotNull(ergebnis[1].KartenModels);

			Assert.Equal(_spielerDreiName, ergebnis[2].SpielerModel.SpielerName);
			Assert.Equal(_spielerDreiId, ergebnis[2].SpielerModel.Id);
			Assert.NotNull(ergebnis[2].KartenModels);
		}

		[Theory]
		[InlineData(2)]
		[InlineData(3)]
		[InlineData(4)]
		[InlineData(5)]
		private void InitialeKartenVerteilungTest(int anzahlSpieler)
		{
			//arrange
			var _anzahlSpieler = anzahlSpieler;

			BeispielMultipleSpielerModelsFüllen(_anzahlSpieler);

			foreach (var spieler in SpielerModels)
			{
				UnoRegeln.SpielerErstellen(spieler.SpielerName);
			}

			UnoRegeln.ZiehKartenStapelZusammenstellen();

			//act
			UnoRegeln.InitialeKartenVerteilung();

			//assert
			foreach (var spieler in UnoRegeln.Spieler)
			{
				Assert.Equal(7, spieler.KartenModels.Count());
			}
		}

		[Theory]
		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 2, 3)]
		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 3, 2)]
		[InlineData("Thomas", 1, "Mike", 2, "Robin", 3, true, 2, 3)]
		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 3, 1)]
		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 1, 3)]
		private void NaechsterSpielerTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId, bool uhrZeigerSinn, int aktuellerSpieler, int naechsterErwartung)
		{
			//arrange
			var _spielerEinsName = spielerEinsName;
			var _spielerEinsId = spielerEinsId;
			var _spielerZweiName = spielerZweiName;
			var _spielerZweiId = spielerZweiId;
			var _spielerDreiName = spielerDreiName;
			var _spielerDreiId = spielerDreiId;
			var _uhrZeigerSinn = uhrZeigerSinn;
			var _aktuellerSpieler = aktuellerSpieler;
			var _naechsterErwartung = naechsterErwartung;

			//act
			UnoRegeln.SpielerErstellen(_spielerEinsName);
			UnoRegeln.SpielerErstellen(_spielerZweiName);
			UnoRegeln.SpielerErstellen(_spielerDreiName);
			UnoRegeln.NaechsterSpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);

			//assert
			Assert.Equal(_naechsterErwartung, UnoRegeln.NaechsterSpielerId);

		}

		#endregion

		[Theory]
		[InlineData(Farbe.Rot, Farbe.Rot, true)]
		[InlineData(Farbe.Blau, Farbe.Rot, false)]
		[InlineData(Farbe.Rot, Farbe.Blau, false)]
		[InlineData(Farbe.Blau, Farbe.Blau, true)]
		[InlineData(Farbe.Gelb, Farbe.Rot, false)]
		[InlineData(Farbe.Gruen, Farbe.Gruen, true)]
		private void IstAblageStapelFarbeGleichZuLegendeKarteTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
		{
			//arrange
			var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
			var _neueKarteFarbe = neueKarteFarbe.ToString();
			var _erwartet = erwartet;


			//act
			UnoRegeln.AblageKartenStapel.KartenModels = new();
			UnoRegeln.AblageKartenStapel.KartenModels.Add(
				BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false)
				);
			var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);

			//assert
			Assert.Equal(_erwartet, erhalten);
		}

		[Theory]
		[InlineData(Kartenbezeichnung.Acht, Kartenbezeichnung.Acht, true)]
		[InlineData(Kartenbezeichnung.Eins, Kartenbezeichnung.Acht, false)]
		[InlineData(Kartenbezeichnung.Fuenf, Kartenbezeichnung.Vier, false)]
		[InlineData(Kartenbezeichnung.Sechs, Kartenbezeichnung.Sechs, true)]
		[InlineData(Kartenbezeichnung.Zwei, Kartenbezeichnung.Drei, false)]
		[InlineData(Kartenbezeichnung.Neun, Kartenbezeichnung.Acht, false)]
		private void IstAblageStapelZahlGleichZuLegendeKarteTest(Kartenbezeichnung ablegeStapelKarteBezeichnung, Kartenbezeichnung handStapelKarteBezeichnung, bool erwartet)
		{
			//arrange
			var _ablegeStapelKarteBezeichnung = ablegeStapelKarteBezeichnung.ToString();
			var _handStapelKarteBezeichnung = handStapelKarteBezeichnung.ToString();
			var _erwartet = erwartet;

			//act
			UnoRegeln.AblageKartenStapel.KartenModels = new();
			UnoRegeln.AblageKartenStapel.KartenModels.Add(
				BeispielKarte(_ablegeStapelKarteBezeichnung, Farbe.Blau.ToString(), false)
				);
			var erhalten = UnoRegeln.IstAblageStapelZahlGleichZuLegendeKarte(_handStapelKarteBezeichnung);

			//assert
			Assert.Equal(_erwartet, erhalten);

		}

		[Fact]
		private void ZiehEineKarteTest()
		{
			//arrange
			UnoRegeln.ZiehKartenStapelZusammenstellen();
			UnoRegeln.SpielerErstellen("Andrej");

			var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();

			//act
			UnoRegeln.ZiehEineKarte(1);

			var erhalten = UnoRegeln.Spieler[0].KartenModels.LastOrDefault();

			//assert
			Assert.Equal(erwartet, erhalten);
		}

		[Theory]
		[InlineData(2, 0, 1)]
		[InlineData(3, 2, 0)]
		[InlineData(4, 2, 3)]
		[InlineData(5, 0, 1)]
		private void PlusZweiKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerIndex, int naechsterSpielerIndex)
		{
			//arrange
			UnoRegeln.ZiehKartenStapelZusammenstellen();
			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);

			foreach (var spieler in SpielerModels)
			{
				UnoRegeln.SpielerErstellen(spieler.SpielerName);
			}

			var _aktuellerSpielerIndex = aktuellerSpielerIndex;
			var _naechsterSpielerIndex = naechsterSpielerIndex;
			var nachstenSpielerKartenAnzahlErwartet = UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels.Count + 2;

			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.PlusZweiKarte.ToString(), Farbe.Gelb.ToString(), true);

			//act
			UnoRegeln.KarteAufStapelLegen(UnoRegeln.Spieler[_aktuellerSpielerIndex].SpielerModel.Id, beispielZuLegendeKarte);

			//assert
			Assert.Equal(nachstenSpielerKartenAnzahlErwartet, UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels.Count);
			Assert.DoesNotContain(UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels[0], UnoRegeln.ZiehKartenStapel.KartenModels);
			Assert.DoesNotContain(UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels[1], UnoRegeln.ZiehKartenStapel.KartenModels);
		}


		[Theory]
		[InlineData(4, 0, 3, true)]
		[InlineData(4, 0, 1, false)]
		[InlineData(4, 2, 3, false)]
		[InlineData(4, 3, 2, true)]
		[InlineData(3, 1, 2, false)]
		private void RetoureKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerIndex, int naechsterSpielerIndex, bool uhrzeigerSinn)
		{
			//arrange
			UnoRegeln.ZiehKartenStapelZusammenstellen();
			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);

			foreach (var spieler in SpielerModels)
			{
				UnoRegeln.SpielerErstellen(spieler.SpielerName);
			}

			var erwartet = !uhrzeigerSinn;
			var _aktuellerSpielerIndex = aktuellerSpielerIndex;
			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.RetoureKarte.ToString(), Farbe.Gelb.ToString(), true);

			//act
			UnoRegeln.Uhrzeigersinn = uhrzeigerSinn;
			UnoRegeln.KarteAufStapelLegen(UnoRegeln.Spieler[_aktuellerSpielerIndex].SpielerModel.Id, beispielZuLegendeKarte);

			//assert
			Assert.Equal(naechsterSpielerIndex, UnoRegeln.Spieler.FindIndex(x => x.SpielerModel.Id == UnoRegeln.NaechsterSpielerId));
		}

		[Theory]
		[InlineData(4, 1, 3, true)]
		[InlineData(4, 1, 3, false)]
		[InlineData(4, 2, 4, true)]
		[InlineData(4, 2, 4, false)]
		[InlineData(4, 3, 1, true)]
		[InlineData(4, 3, 1, false)]
		[InlineData(6, 1, 3, true)]
		[InlineData(6, 1, 5, false)]
		[InlineData(6, 2, 4, true)]
		[InlineData(6, 2, 6, false)]
		[InlineData(6, 3, 5, true)]
		[InlineData(6, 3, 1, false)]
		[InlineData(6, 4, 6, true)]
		[InlineData(6, 4, 2, false)]
		[InlineData(6, 5, 1, true)]
		[InlineData(6, 5, 3, false)]
		[InlineData(6, 6, 2, true)]
		[InlineData(6, 6, 4, false)]
		private void AussetzenKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerId, int naechsterSpielerId, bool uhrzeigerSinn)
		{
			//arrange
			UnoRegeln.ZiehKartenStapelZusammenstellen();
			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);

			foreach (var spieler in SpielerModels)
			{
				UnoRegeln.SpielerErstellen(spieler.SpielerName);
			}

			var erwartetNaechsterSpielerId = naechsterSpielerId;
			var _aktuellerSpielerId = aktuellerSpielerId;
			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.AussetzenKarte.ToString(), Farbe.Rot.ToString(), true);
			UnoRegeln.Uhrzeigersinn = uhrzeigerSinn;

			//act
			UnoRegeln.KarteAufStapelLegen(_aktuellerSpielerId, beispielZuLegendeKarte);

			//assert
			Assert.Equal(erwartetNaechsterSpielerId, UnoRegeln.NaechsterSpielerId);
		}

		#region Stapel erstellen
		[Theory]
		[InlineData((Kartenbezeichnung)0, Farbe.Rot, false, 19)]
		[InlineData((Kartenbezeichnung)1, Farbe.Rot, false, 19)]
		[InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
		[InlineData((Kartenbezeichnung)3, Farbe.Gruen, false, 19)]
		[InlineData((Kartenbezeichnung)4, Farbe.Rot, false, 19)]
		[InlineData((Kartenbezeichnung)5, Farbe.Blau, false, 19)]
		[InlineData((Kartenbezeichnung)6, Farbe.Gruen, false, 19)]
		[InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
		[InlineData((Kartenbezeichnung)8, Farbe.Gruen, false, 19)]
		[InlineData((Kartenbezeichnung)9, Farbe.Gelb, false, 19)]
		private void ErstelleStandardKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
		{
			//arrange
			var _kartenbezeichnung = kartenbezeichnung.ToString();
			var _farbe = farbe.ToString();
			var _spezial = spezial;
			var _anzahl = anzahl;
			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

			//act
			var neuesDeck = Uno.ErstelleStandardKarten();
			var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
			var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
			var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
			var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();

			//assert           
			Assert.Equal(_anzahl, anzahlBlau);
			Assert.Equal(_anzahl, anzahlRot);
			Assert.Equal(_anzahl, anzahlGruen);
			Assert.Equal(_anzahl, anzahlGelb);

			Assert.Contains(neuesDeck.KartenModels, n =>
				n.Name.Equals(erwartet.Name) &&
				n.Farbe.Equals(erwartet.Farbe) &&
				n.Spezial == erwartet.Spezial
			);
		}

		[Theory]
		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true, 6)]
		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Blau, true, 6)]
		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gruen, true, 6)]
		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Rot, true, 6)]
		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gelb, true, 6)]
		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Blau, true, 6)]
		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gruen, true, 6)]
		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Rot, true, 6)]
		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gelb, true, 6)]
		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Blau, true, 6)]
		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gruen, true, 6)]
		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Rot, true, 6)]
		private void ErstelleFarbigeSpezialKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
		{
			//arrange
			var _kartenbezeichnung = kartenbezeichnung.ToString();
			var _farbe = farbe.ToString();
			var _spezial = spezial;
			var _anzahl = anzahl;
			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

			//act
			var neuesDeck = Uno.ErstelleFarbigeSpezialKarten();
			var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
			var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
			var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
			var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();


			//assert
			Assert.Equal(_anzahl, anzahlBlau);
			Assert.Equal(_anzahl, anzahlRot);
			Assert.Equal(_anzahl, anzahlGruen);
			Assert.Equal(_anzahl, anzahlGelb);

			Assert.Contains(neuesDeck.KartenModels, n =>
				n.Name.Equals(erwartet.Name) &&
				n.Farbe.Equals(erwartet.Farbe) &&
				n.Spezial == erwartet.Spezial
			);
		}

		[Theory]
		[InlineData(Kartenbezeichnung.FarbwahlKarte, Farbe.Keine, true, 4)]
		[InlineData(Kartenbezeichnung.ZiehVierFarbenwahlkarte, Farbe.Keine, true, 4)]
		private void ErstelleJokerKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
		{
			//arrange
			var _kartenbezeichnung = kartenbezeichnung.ToString();
			var _farbe = farbe.ToString();
			var _spezial = spezial;
			var _anzahl = anzahl;
			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

			//act
			var neuesDeck = Uno.ErstelleJokerKarten();
			var ergebnisAnzahl = neuesDeck.KartenModels.Where(x => x.Name.Equals(kartenbezeichnung.ToString())).Count();

			//assert
			Assert.Equal(_anzahl, ergebnisAnzahl);
			Assert.Contains(neuesDeck.KartenModels, n =>
				n.Name.Equals(erwartet.Name) &&
				n.Farbe.Equals(erwartet.Farbe) &&
				n.Spezial == erwartet.Spezial
			);
		}

		[Fact]
		private void AblagestapelZusammenstellenTest()
		{

			UnoRegeln.ZiehKartenStapelZusammenstellen();

			var ergebnis = UnoRegeln.ZiehKartenStapel;

			Assert.Equal(108, ergebnis.KartenModels.Count());
		}

		#endregion
	}
}