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();

        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()
            {
                Id = 1,
                Name = "Andrej",
                KartenModels = new()
                {
                    new KartenModel
                    {
                        Name = Kartenbezeichnung.PlusZweiKarte.ToString(),
                        Farbe = Farbe.Gelb.ToString(),
                        Spezial = true
                    }
                }
            };

            return HandStapel;
        }

        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].Name);
            Assert.Equal(_id, ergebnis[0].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].Name);
            Assert.Equal(_spielerEinsId, ergebnis[0].Id);
            Assert.NotNull(ergebnis[0].KartenModels);

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

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


        #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.KartenAblageStapel.KartenModels = new();
            UnoRegeln.KartenAblageStapel.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.KartenAblageStapel.KartenModels = new();
            UnoRegeln.KartenAblageStapel.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(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true)]
        private void PlusZweiKarteAufStapelLegenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
        {
            //arrange
            UnoRegeln.ZiehKartenStapelZusammenstellen();
            var kartenAblageStapel = UnoRegeln.KartenAblageStapel;
            var ziehKartenStapel = UnoRegeln.ZiehKartenStapel;

            var _kartenbezeichnung = kartenbezeichnung.ToString();
            var _farbe = farbe.ToString();
            var _spezial = spezial;
            var naechstenHand = BeispielHand();
            var beispielZuLegendeKarte = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);


            //act
            //naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);

            //assert
        }

        #region Stapel erstellen
        [Theory]
        [InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
        [InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
        [InlineData((Kartenbezeichnung)9, 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)]
        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.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.RetoureKarte, Farbe.Gelb, true, 6)]
        [InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gruen, true, 6)]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, 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
    }
}