RPGLibrary/RPGLibrary.Test/CommandExecuterTest.cs

using RPGLibrary.Command;
using RPGLibrary.Implementation;
using RPGLibrary.Implementation.Command;

namespace RPGLibrary.Test
{
  public class CommandExecuterTest
  {
    [Test]
    public async Task GivenAttackExpectHPIsReduced()
    {
      var source = new Character("A", new HP(38, 120), new StrengthAttribute(7), new DefenseAttribute(5));
      var target = new Character("B", new HP(95, 100), new StrengthAttribute(7), new DefenseAttribute(5));
      var damageCalculator = new StrengthBasedDamageCalculator();

      var attackData = new StrengthAttackData(source, source.Strength);
      var command = new AttackCommand(new[] { target }, attackData, damageCalculator);
      var commands = new[] { command };
      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());
      var actual = new List<Character>();

      await foreach (var resultOfCommand in results)
      {
        await foreach (var resultOfAttack in resultOfCommand)
          actual.Add((Character)resultOfAttack);

      }

      Assert.That(actual[0].HP.Value, Is.EqualTo(93));
    }

    [Test]
    public async Task MultiHitAttackTest()
    {
      var source = new Character("A", new HP(100, 100), new StrengthAttribute(10), new DefenseAttribute(4));
      var target = new[]
      {
        new Character("B", new HP(38, 100), new StrengthAttribute(12), new DefenseAttribute(4)),
        new Character("C", new HP(47, 100), new StrengthAttribute(18), new DefenseAttribute(6)),
        new Character("D", new HP(99, 100), new StrengthAttribute(11), new DefenseAttribute(2))
      };

      var damageCalculator = new StrengthBasedDamageCalculator();
      var attackData = new StrengthAttackData(source, source.Strength);
      var command = new AttackCommand(target, attackData, damageCalculator);

      var commands = new[] { command };
      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());
      var actual = new List<Character>();

      await foreach (var resultOfCommand in results)
      {
        await foreach (var resultOfAttack in resultOfCommand)
          actual.Add((Character)resultOfAttack);

      }

      Assert.That(actual[0].HP.Value, Is.EqualTo(32));
      Assert.That(actual[1].HP.Value, Is.EqualTo(43));
      Assert.That(actual[2].HP.Value, Is.EqualTo(91));
    }

    [Test]
    public async Task QueueAttacks()
    {
      var source = new Character("A", new HP(100, 100), new StrengthAttribute(10), new DefenseAttribute(4));
      var target = new[]
      {
        new Character("B", new HP(38, 100), new StrengthAttribute(12), new DefenseAttribute(4)),
        new Character("C", new HP(47, 100), new StrengthAttribute(18), new DefenseAttribute(6)),
        new Character("D", new HP(99, 100), new StrengthAttribute(11), new DefenseAttribute(2))
      };

      var damageCalculator = new StrengthBasedDamageCalculator();
      var attackData = new StrengthAttackData(source, source.Strength);
      var commandA = new AttackCommand(target, attackData, damageCalculator);
      var commandB = new AttackCommand(target, attackData, damageCalculator);
      var commandC = new AttackCommand(target, attackData, damageCalculator);

      var commands = new[] { commandA, commandB, commandC };
      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());

      await foreach (var resultOfCommand in results)
      {
        var characterList = new List<Character>();
        await foreach (var r in resultOfCommand)
        {
          characterList.Add((Character)r);
        }

        Assert.That(characterList[0].HP.Value, Is.EqualTo(32));
        Assert.That(characterList[1].HP.Value, Is.EqualTo(43));
        Assert.That(characterList[2].HP.Value, Is.EqualTo(91));
      }
    }
  }
}