Tests - 1+2=3

        [TestMethod]
        public void Add_When_Add_1_And_2_Should_Return_3()
        {
            // arrange
            var calculation = new Calculation();
            // act
            var result = calculation.Add(1, 2);
            // assert
            Assert.AreEqual(3, result);
        }

Tests - 2+1=3

        [TestMethod]
        public void Add_When_Add_2_And_1_Should_Return_3()
        {
            // arrange
            var calculation = new Calculation();
            // act
            var result = calculation.Add(2, 1);
            // assert
            Assert.AreEqual(3, result);
        }

Tests - 1+0=1

        [TestMethod]
        public void Add_When_Add_1_And_0_Should_Return_1()
        {
            // arrange
            var calculation = new Calculation();
            // act
            var result = calculation.Add(1, 0);
            // assert
            Assert.AreEqual(1, result);
        }

Tests - 1+(-1)=0

        [TestMethod]
        public void Add_When_Add_1_And_Minus_1_Should_Return_0()
        {
            // arrange
            var calculation = new Calculation();
            // act
            var result = calculation.Add(1, -1);
            // assert
            Assert.AreEqual(0, result);
        }

Stub code

    public class Calculation
    {
        public int Add(int x, int y)
        {
            throw new NotImplementedException();
        }
    }

Run the tests

Write actual code

    public class Calculation
    {
        public int Add(int x, int y)
        {
            return x + y;
        }
    }

Run the tests again

Fake it till you make it

• if operand is "+", call Add function
• if operand is "-", call Minus function
• if operand is "*", call Multiply function
• if operand is "/", call DivideBy function

Define the interface

    public interface ICalculation
    {
        int Add(int x, int y);
        int Minus(int x, int y);
        int Multiply(int x, int y);
        int DivideBy(int x, int y);
    }

Write tests

        [TestMethod]
        public void GetResults_When_Pass_In_Plus_Should_Call_Add()
        {
            // arrange
            var calculation = Substitute.For<ICalculation>();
            calculation.Add(1, 2).Returns(3);
            var controller = new Controller(calculation);
            // act
            var result = controller.GetResult("1", "2", "+");
            // assert
            calculation.Received(1).Add(1, 2);
            Assert.AreEqual(3, result);
        }

Implement the code

public class Controller
{
    private readonly ICalculation calculation;

    public Controller(ICalculation calculation) 
    {
        this.calculation = calculation;
    }

    public int GetResult(string operand1, string operand2, string op)
    {
        var op1 = Int32.Parse(operand1);
        var op2 = Int32.Parse(operand2);

        switch (op)
        {
            case "+":
                return calculation.Add(op1, op2);
            case "-":
                return calculation.Minus(op1, op2);
            case "*":
                return calculation.Multiply(op1, op2);
            case "/":
                return calculation.DivideBy(op1, op2);
            default:
                throw new ArgumentException("Unrecognised operator");
        }
    }
}