Continous Integration in der Praxis Gruppenarbeit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

536 lines
17 KiB

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(2, 1)]
[InlineData(3, 1)]
[InlineData(4, 1)]
[InlineData(5, 1)]
[InlineData(6, 1)]
[InlineData(7, 1)]
[InlineData(8, 1)]
private void MehrereSpielerErstellenTest(int anzahlSpieler, int id)
{
//arrange
var _anzahlSpieler = anzahlSpieler;
string[] _spielerName = new string[anzahlSpieler];
var _id = id;
//act
for (int i = 0; i < _anzahlSpieler; i++)
{
_spielerName[i] = "Spieler" + i;
UnoRegeln.SpielerErstellen(_spielerName[i]);
}
var ergebnis = UnoRegeln.Spieler;
//assert
for (int i = 0; i < _anzahlSpieler; i++)
{
Assert.Equal(_spielerName[i], ergebnis[i].SpielerModel.SpielerName);
Assert.Equal(_id++, ergebnis[i].SpielerModel.Id);
Assert.NotNull(ergebnis[i].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(3, true, 2, 3)]
[InlineData(3, true, 3, 1)]
[InlineData(4, true, 1, 2)]
[InlineData(4, true, 3, 4)]
[InlineData(4, true, 4, 1)]
[InlineData(6, true, 4, 5)]
[InlineData(6, true, 5, 6)]
[InlineData(3, false, 3, 2)]
[InlineData(3, false, 1, 3)]
[InlineData(4, false, 1, 4)]
[InlineData(4, false, 4, 3)]
[InlineData(6, false, 6, 5)]
[InlineData(6, false, 4, 3)]
private void NaechsterSpielerTest(int anzahlSpieler, bool uhrZeigerSinn, int aktuellerSpielerId, int naechsterErwartungId)
{
//arrange
var _uhrZeigerSinn = uhrZeigerSinn;
var _aktuellerSpielerId = aktuellerSpielerId;
var _naechsterSpielerIdErwartung = naechsterErwartungId;
//act
for (int i = 0; i < anzahlSpieler; i++)
{
UnoRegeln.SpielerErstellen("Spieler " + i);
}
UnoRegeln.NaechsterSpielerWahl(_aktuellerSpielerId, _uhrZeigerSinn);
//assert
Assert.Equal(_naechsterSpielerIdErwartung, 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
}
}