public void CanGetRolls()
{
var roller = new RollController(new DiceRoller());
var result = roller.Get(1);
result.ShouldBeEquivalentTo(1);
}
public void Can_Dice_Roll()
{
var numberOfDice = 1;
var numberOfSides = 6;
var result = RollController.Rolling(numberOfDice, numberOfSides);
Assert.That(result.Results.Length, Is.EqualTo(1));
Assert.That(result.Total, Is.GreaterThanOrEqualTo(1));
Assert.That(result.Total, Is.LessThanOrEqualTo(6));
}
public void Can_Get_Number_Of_Sides()
{
var numberOfSides_below10 = RollController.GetNumberOfSides("1d2");
Assert.IsTrue(Convert.ToInt32(numberOfSides_below10.Value) == 2);
var numberOfSides_above10 = RollController.GetNumberOfSides("10d20");
Assert.IsTrue(Convert.ToInt32(numberOfSides_above10.Value) == 20);
}
public void Can_Get_Number_Of_Dice()
{
var numberOfDice_below10 = RollController.GetNumberOfDice("1d20");
Assert.IsTrue(Convert.ToInt32(numberOfDice_below10.Value) == 1);
var numberOfDice_above10 = RollController.GetNumberOfDice("20d20");
Assert.IsTrue(Convert.ToInt32(numberOfDice_above10.Value) == 20);
}
public async Task Roll_InvalidId_ReturnCharacterNotFound()
{
// Arrange
var provider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
var result = await controller.RollStatisticAsync(0, "strength");
// Assert
Assert.Equal(CharacterResult.CharacterNotFound(), result);
}
public async Task Roll_InvalidStat_ReturnStatNotFound()
{
// Arrange
var provider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
var result = await controller.RollStatisticAsync(1, "invalid");
// Assert
Assert.True(StatisticResult.StatisticNotFound().Equals(result));
}
public async Task RollAgainst_InvalidStatValues_ReturnRollFailed()
{
// Arrange
var provider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
var result = await controller.RollStatisticAgainstAsync(1, 2, "strength");
// Assert
Assert.Equal(RollResult.RollFailed(), result);
}
public void Can_Validate_Dice_Roll_Input()
{
var validated = RollController.ValidateDiceRoll("1d20");
Assert.IsTrue(validated.Success);
var validated_cake = RollController.ValidateDiceRoll("Cake");
Assert.IsFalse(validated_cake.Success);
var validated_null = RollController.ValidateDiceRoll("");
Assert.IsFalse(validated_null.Success);
}
public async Task Roll_InvalidStatValues_ReturnRollFailed()
{
// Arrange
var statProvider = new MockStatisticProvider();
var strength = await statProvider.GetStatisticAsync("Strength");
var provider = new MockCharacterProvider();
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
// Character should have null or empty Statistics list.
var result = await controller.RollStatisticAsync(1, "strength");
// Assert
Assert.True(RollResult.RollFailed().Equals(result));
}
public async Task RollAgainst_ValidValues_ReturnSuccess()
{
// Arrange
var statProvider = new MockStatisticProvider();
var strength = await statProvider.GetStatisticAsync("Strength");
var provider = new MockCharacterProvider();
// Give characters statistics
(await provider.GetAllCharactersAsync(1))[0].SetStatistic(strength, new StatisticValue(5));
(await provider.GetAllCharactersAsync(2))[0].SetStatistic(strength, new StatisticValue(5));
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
var result = await controller.RollStatisticAgainstAsync(1, 2, "strength");
// Assert
Assert.True(result.GetType() == typeof(RollResult) && result.IsSuccess);
}
public async Task Roll(string userInput)
{
//Validate the User input to make sure is in corret format
Match diceValidation = RollController.ValidateDiceRoll(userInput);
// If the Validation is Successful
if (diceValidation.Success)
{
var msg = Context.Message;
var discordId = msg.Author.Username;
int numberOfDiceRolledInt = Convert.ToInt32(RollController.GetNumberOfDice(userInput).Value);
int numberOfSidesOnDiceInt = Convert.ToInt32(RollController.GetNumberOfSides(userInput).Value);
// If the number of dice or number of sides is above 100 display this message
if (numberOfSidesOnDiceInt > 100 || numberOfDiceRolledInt > 100)
{
await ReplyAsync(Resources.error_Too_Many_Dice);
}
// If the number of sides is 1 display this message
else if (numberOfSidesOnDiceInt == 1)
{
await ReplyAsync(Resources.error_OneSide_Dice);
}
// If the User input is correct and passes the checks run this
else
{
DiceResults rolledDice = RollController.Rolling(numberOfDiceRolledInt, numberOfSidesOnDiceInt);
// Send all the Information back into the chat to the user
//await ReplyAsync($"{discordId} Rolled: \r\n{rolledDice.Results} \r\nTotal: {rolledDice.Total.ToString()}");
await ReplyAsync(string.Format(Resources.response_Dice_Roll, discordId, rolledDice.Results, rolledDice.Total));
}
}
else
{
//If the input is in an incorrect format display this message.
await ReplyAsync(Resources.error_Incorrect_Format_Dice);
}
}
public async Task Roll_ValidValues_ReturnSuccess()
{
// Arrange
var statProvider = new MockStatisticProvider();
var strength = await statProvider.GetStatisticAsync("Strength");
var provider = new MockCharacterProvider();
var chars = await provider.GetAllCharactersAsync(1);
// Give the new character a Statistic to test
chars[0].SetStatistic(strength, new StatisticValue(5));
await provider.UpdateCharacterAsync(chars[0]);
var controller = new RollController(provider, statProvider, new MockRollStrategy());
// Act
var result = await controller.RollStatisticAsync(1, "strength");
// Assert
Assert.True(result.GetType() == typeof(RollResult) && result.IsSuccess);
}
public RollModule(RollController controller)
{
_controller = controller;
}
