New Tricks from an Old Pattern

ScoreChecker.cs

public class ScoreChecker
{
    public IPlayer GetScoredPlayer(IPlayer player)
    {
        if (player.Score > 8)
        {
            return new HighScorePlayer(player);
        }

        if (player.Score > 2)
        {
            return new LowScorePlayer(player);
        }

        throw new ScoreTooLowException();
    }
}

ScoreCheckerTests1.cs

public abstract class WhenIGetScoredPlayer : GivenA<ScoreChecker>
{
    protected readonly Mock<IPlayer> MockPlayer = new Mock<IPlayer>();
    protected IPlayer Result = null;

    protected override void When()
    {
        base.When();

        Result = Target.GetScoredPlayer(MockPlayer.Object);
    }
}

public class GivenThePlayerHasAScoreGreaterThan8 : WhenIGetScoredPlayer
{
    protected override void Given()
    {
        base.Given();

        MockPlayer.Setup(m => m.Score).Returns(9);
    }

    [Then]
    public void TheResultIsAHighScorePlayer()
    {
        Assert.IsInstanceOf<HighScorePlayer>(Result);
    }
}

public class GivenThePlayerHasAScoreGreaterThan2 : WhenIGetScoredPlayer
{
    protected override void Given()
    {
        base.Given();

        MockPlayer.Setup(m => m.Score).Returns(3);
    }

    [Then]
    public void TheResultIsALowScorePlayer()
    {
        Assert.IsInstanceOf<LowScorePlayer>(Result);
    }
}

ScoreCheckerTests2.cs

public class GivenThePlayerHasAScoreLowerThan2 : WhenIGetScoredPlayer
{
    protected override void Given()
    {
        base.Given();

        MockPlayer.Setup(m => m.Score).Returns(1);
    }
    
    protected override void When()
    {
        // prevent base.When() from being called
        // and throwing an exception too early!
    }

    [Then]
    public void AScoreTooLowExceptionIsThrown()
    {
        Assert.Throws<ScoreTooLowException>(() => base.When());
    }
}