refactoring vom AussetzenKarteAufStapelLegenTest Code

Code in eine Methode extrahiert

BlazorSolution/MiniGames/Client/ViewModel/Uno.cs

@@ -1,6 +1,5 @@
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -8,16 +7,17 @@ namespace MiniGames.Client.ViewModel
 {
 	public class Uno : IUno
 	{
-        public StapelModel KartenAblageStapel { get; set; } = new();
+		public StapelModel AblageKartenStapel { get; set; } = new();
 		public StapelModel ZiehKartenStapel { get; set; } = new();
 		public List<HandKartenModel> Spieler { get; set; } = new();
 		public int NaechsterSpielerId { get; set; }
+		public bool Uhrzeigersinn { get; set; } = true;
 
 		public bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe)
 		{
 			bool ergebnis;
 
-            _ = KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
+			_ = AblageKartenStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
 
 			return ergebnis;
 		}
@@ -26,7 +26,7 @@ namespace MiniGames.Client.ViewModel
 		{
 			bool ergebnis;
 
-            _ = KartenAblageStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
+			_ = AblageKartenStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
 
 			return ergebnis;
 		}
@@ -42,16 +42,18 @@ namespace MiniGames.Client.ViewModel
 
 		public void KarteAufStapelLegen(int id, KartenModel zuLegendeKarte)
 		{
-            int _id = id;
+			NaechsterSpielerWahl(id, Uhrzeigersinn);
+			int _naechstenId = NaechsterSpielerId;
+
 			StapelModel _stapelModel = new();
 			_stapelModel.KartenModels = new();
 			const string _plusZweiKarte = "PlusZweiKarte";
 			const string _retoureKarte = "RetoureKarte";
 			const string _aussetzenKarte = "AussetzenKarte";
 
-            if (KartenAblageStapel.KartenModels is null)
+			if (AblageKartenStapel.KartenModels is null)
 			{
-                KartenAblageStapel.KartenModels = new();
+				AblageKartenStapel.KartenModels = new();
 			}
 
 			switch (zuLegendeKarte.Name)
@@ -59,13 +61,18 @@ namespace MiniGames.Client.ViewModel
 				case _plusZweiKarte:
 					for (int i = 0; i < 2; i++)
 					{
-                        ZiehEineKarte(_id);
+						ZiehEineKarte(_naechstenId);
 					}
 					break;
+
 				case _retoureKarte:
+					_naechstenId = RetoureKarte(id);
 					break;
+
 				case _aussetzenKarte:
+					AussetzenKarteSpielerWahl(id, Uhrzeigersinn);
 					break;
+
 				default:
 					break;
 
@@ -73,6 +80,13 @@ namespace MiniGames.Client.ViewModel
 
 		}
 
+		private int RetoureKarte(int id)
+		{
+			Uhrzeigersinn = !Uhrzeigersinn;
+			NaechsterSpielerWahl(id, Uhrzeigersinn);
+			return NaechsterSpielerId;
+		}
+
 		public void SpielerErstellen(string spielerName)
 		{
 			string _spielerName = spielerName;
@@ -88,7 +102,7 @@ namespace MiniGames.Client.ViewModel
 				});
 		}
 
-        public void SpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
+		public void NaechsterSpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
 		{
 			var aktuellerSpielerIndex = Spieler.FindIndex(x => x.SpielerModel.Id == aktuellerSpielerId);
 			if (uhrZeigerSinn)
@@ -115,6 +129,40 @@ namespace MiniGames.Client.ViewModel
 			}
 		}
 
+		private void AussetzenKarteSpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
+		{
+			if (uhrZeigerSinn)
+			{
+				if (aktuellerSpielerId == Spieler.LastOrDefault().SpielerModel.Id)
+				{
+					NaechsterSpielerId = 2;
+				}
+				else if (aktuellerSpielerId == Spieler.LastOrDefault().SpielerModel.Id - 1)
+				{
+					NaechsterSpielerId = 1;
+				}
+				else
+				{
+					NaechsterSpielerId = aktuellerSpielerId + 2;
+				}
+			}
+			else
+			{
+				if (aktuellerSpielerId > 2)
+				{
+					NaechsterSpielerId = aktuellerSpielerId - 2;
+				}
+				else if (aktuellerSpielerId == 2)
+				{
+					NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id;
+				}
+				else
+				{
+					NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id - 1;
+				}
+			}
+		}
+
 		#region Stapel Erstellen
 		public static StapelModel ErstelleStandardKarten()
 		{
@@ -122,23 +170,34 @@ namespace MiniGames.Client.ViewModel
 			stapelModel.KartenModels = new();
 			for (int f = 1; f <= 4; f++)
 			{
-                for (int k = 1; k <= 19; k++)
+				EinzelneKarteErstellen(stapelModel, f, 0, false);
+
+				for (int k = 1; k <= 9; k++)
+				{
+					for (int a = 0; a < 2; a++)
 					{
-                    var kartenbezeichnung = (Kartenbezeichnung)k;
-                    var kartenfarbe = (Farbe)f;
+						EinzelneKarteErstellen(stapelModel, f, k, false);
+					}
+				}
+
+			}
+
+			return stapelModel;
+		}
+
+		private static void EinzelneKarteErstellen(StapelModel stapelModel, int farbenIndex, int kartenbezeichungIndex, bool spezial)
+		{
+			var kartenbezeichnung = (Kartenbezeichnung)kartenbezeichungIndex;
+			var kartenfarbe = (Farbe)farbenIndex;
 			stapelModel.KartenModels.Add(
 				new KartenModel
 				{
 					Name = kartenbezeichnung.ToString(),
 					Farbe = kartenfarbe.ToString(),
-                            Spezial = false
+					Spezial = spezial
 				}
 				);
 		}
-            }
-
-            return stapelModel;
-        }
 
 		public static StapelModel ErstelleFarbigeSpezialKarten()
 		{
@@ -150,16 +209,7 @@ namespace MiniGames.Client.ViewModel
 				{
 					for (int i = 0; i < 2; i++)
 					{
-                        var _kartenbezeichnung = (Kartenbezeichnung)k;
-                        var kartenfarbe = (Farbe)f;
-                        stapelModel.KartenModels.Add(
-                            new KartenModel
-                            {
-                                Name = _kartenbezeichnung.ToString(),
-                                Farbe = kartenfarbe.ToString(),
-                                Spezial = true
-                            }
-                            );
+						EinzelneKarteErstellen(stapelModel, f, k, true);
 					}
 				}
 			}
@@ -167,6 +217,18 @@ namespace MiniGames.Client.ViewModel
 			return stapelModel;
 		}
 
+		public void InitialeKartenVerteilung()
+		{
+			for (int i = 0; i < 7; i++)
+			{
+				foreach (var spieler in Spieler)
+				{
+					spieler.KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+					ZiehKartenStapel.KartenModels.RemoveAt(0);
+				}
+			}
+		}
+
 		public static StapelModel ErstelleJokerKarten()
 		{
 			StapelModel stapelModel = new();

BlazorSolution/MiniGames/Shared/Enums/Enums.cs

@@ -9,6 +9,7 @@ namespace MiniGames.Shared.Enums
     [Flags]
     public enum Kartenbezeichnung
     {
+        Null = 0,
         Eins = 1,
         Zwei = 2,
         Drei = 3,

BlazorSolution/MiniGamesTests/UnoTest.cs

@@ -10,6 +10,7 @@ namespace MiniGamesTests
 	public class UnoTest
 	{
 		public Uno UnoRegeln = new();
+		public List<SpielerModel> SpielerModels = new();
 
 		private KartenModel BeispielKarte(string name, string farbe, bool spezial)
 		{
@@ -51,6 +52,58 @@ namespace MiniGamesTests
 			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;
@@ -122,6 +175,35 @@ namespace MiniGamesTests
 			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)]
@@ -145,7 +227,7 @@ namespace MiniGamesTests
 			UnoRegeln.SpielerErstellen(_spielerEinsName);
 			UnoRegeln.SpielerErstellen(_spielerZweiName);
 			UnoRegeln.SpielerErstellen(_spielerDreiName);
-            UnoRegeln.SpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);
+			UnoRegeln.NaechsterSpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);
 
 			//assert
 			Assert.Equal(_naechsterErwartung, UnoRegeln.NaechsterSpielerId);
@@ -170,8 +252,8 @@ namespace MiniGamesTests
 
 
 			//act
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(
+			UnoRegeln.AblageKartenStapel.KartenModels = new();
+			UnoRegeln.AblageKartenStapel.KartenModels.Add(
 				BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false)
 				);
 			var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
@@ -195,8 +277,8 @@ namespace MiniGamesTests
 			var _erwartet = erwartet;
 
 			//act
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(
+			UnoRegeln.AblageKartenStapel.KartenModels = new();
+			UnoRegeln.AblageKartenStapel.KartenModels.Add(
 				BeispielKarte(_ablegeStapelKarteBezeichnung, Farbe.Blau.ToString(), false)
 				);
 			var erhalten = UnoRegeln.IstAblageStapelZahlGleichZuLegendeKarte(_handStapelKarteBezeichnung);
@@ -225,36 +307,120 @@ namespace MiniGamesTests
 		}
 
 		[Theory]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true)]
-        private void PlusZweiKarteAufStapelLegenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
+		[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();
-            var kartenAblageStapel = UnoRegeln.KartenAblageStapel;
-            var ziehKartenStapel = UnoRegeln.ZiehKartenStapel;
+			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);
 
-            var _kartenbezeichnung = kartenbezeichnung.ToString();
-            var _farbe = farbe.ToString();
-            var _spezial = spezial;
-            var naechstenHand = BeispielHand();
-            var beispielZuLegendeKarte = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
+			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
-            //naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);
+			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)7, Farbe.Blau, false, 19)]
-        [InlineData((Kartenbezeichnung)9, Farbe.Gruen, 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)9, Farbe.Gelb, 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
@@ -286,13 +452,17 @@ namespace MiniGamesTests
 
 		[Theory]
 		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true, 6)]
-        [InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Rot, true, 6)]
-        [InlineData(Kartenbezeichnung.AussetzenKarte, 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.PlusZweiKarte, Farbe.Rot, true, 6)]
+		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Rot, true, 6)]
 		private void ErstelleFarbigeSpezialKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
 		{
 			//arrange