public void ActionPossible_WhenFalseWithSingleError_ReturnsCorrectInfo()
{
var result = ActionPossible.False("You cannot perform this action");
Assert.Multiple(() =>
{
Assert.That(result.IsPossible, Is.False);
Assert.That(result.IsImpossible, Is.True);
Assert.That(result.Errors, Contains.Item("You cannot perform this action"));
});
}
public void ActionPossible_WhenUnauthorized_ReturnsCorrectInfo()
{
var result = ActionPossible.Unauthorized();
Assert.Multiple(() =>
{
Assert.That(result.IsPossible, Is.False);
Assert.That(result.IsImpossible, Is.True);
Assert.That(result.Errors, Contains.Item("Unauthorized Action"));
});
}
public void ActionPossible_WhenTrue_ReturnsCorrectInfo()
{
var result = ActionPossible.True();
Assert.Multiple(() =>
{
Assert.That(result.IsPossible, Is.True);
Assert.That(result.IsImpossible, Is.False);
Assert.That(result.Errors, Is.Empty);
});
}
public void ActionPossible_WhenReturned_StaticErrorListBecomesEmpty_DefaultMessageInErrorList()
{
ActionPossible.AddError("Error message 1");
ActionPossible.AddError("Error message 2");
ActionPossible.AddError("Error message 3");
var result = ActionPossible.FalseWithErrors();
Assert.That(result.Errors.Count(), Is.EqualTo(3));
var nextResult = ActionPossible.FalseWithErrors();
Assert.Multiple(() =>
{
Assert.That(nextResult.Errors.Count(), Is.EqualTo(1));
Assert.That(nextResult.Errors, Contains.Item("You are not allowed to perform this action"));
});
}
public void ActionPossible_WhenFalseWithManyError_ReturnsCorrectInfo()
{
ActionPossible.AddError("Error message 1");
ActionPossible.AddError("Error message 2");
ActionPossible.AddError("Error message 3");
var result = ActionPossible.FalseWithErrors();
Assert.Multiple(() =>
{
Assert.That(result.IsPossible, Is.False);
Assert.That(result.IsImpossible, Is.True);
Assert.That(result.Errors.Count(), Is.EqualTo(3));
Assert.That(result.Errors, Contains.Item("Error message 1"));
Assert.That(result.Errors, Contains.Item("Error message 2"));
Assert.That(result.Errors, Contains.Item("Error message 3"));
});
}
/// <summary>
/// Calcule les actions possible pour le joueur concerné : si aucune action n'est possible renvoie null
/// </summary>
/// <param name="J">Le joueur concerné</param>
/// <returns></returns>
internal Dictionary <TypeActionJoueur, ActionPossible> CalculActionsPossibles(Joueur j)
{
Dictionary <TypeActionJoueur, ActionPossible> actions = null;
if (!j.JeterCartes && j.TapisJoueur > 0)
{
actions = new Dictionary <TypeActionJoueur, ActionPossible>();
// Passe
actions[TypeActionJoueur.Passe] = ActionPossible.Jeter;
// Parole ou suivre
if (
(j.DerniereAction == TypeActionJoueur.GrosseBlind && j == this.DerniereRelance && this.Etape == EtapeDonne.PreFlop) ||
(this.MontantDerniereRelance == 0)
)
{
actions[TypeActionJoueur.Parole] = new ActionPossible(TypeActionJoueur.Parole, 0, 0);
}
else if (j.TapisJoueur >= this.MontantDerniereRelance)
{
// Pour suivre, montant min = la mise actuelle du joueur, montant max = la somme totale à mettre
actions[TypeActionJoueur.Suit] = new ActionPossible(TypeActionJoueur.Suit, j.Mise, this.MontantDerniereRelance);
}
// Relance / mise
if (j.TapisJoueur > this.RelanceMinimum())
{
// Si le joueur est le premier à parler : il mise, sinon il relance
TypeActionJoueur actionJoueur = TypeActionJoueur.Relance;
if (this.MontantDerniereRelance == 0)
{
actionJoueur = TypeActionJoueur.Mise;
}
actions[actionJoueur] = new ActionPossible(actionJoueur, this.RelanceMinimum(), j.TapisJoueur);
}
// Tapis
actions[TypeActionJoueur.Tapis] = new ActionPossible(TypeActionJoueur.Tapis, j.TapisJoueur, j.TapisJoueur);
}
return(actions);
}
public ActionPossible Execute(MakeMeTeaCommand command)
{
return(ActionPossible.True());
}
public ActionPossible Execute(GetMeSomethingValidAsyncQuery query)
{
return(ActionPossible.True());
}
public ActionPossible Execute(MakeMeCoffeCommand command)
{
return(ActionPossible.Unauthorized());
}
public ActionPossible Execute(GetMeSomethingInvalidQuery query)
{
return(ActionPossible.False("I cannot perform this action"));
}
public ActionPossible Execute(GetMeSomethingInvalidAsyncQuery query)
{
return(ActionPossible.Unauthorized());
}