UNIT TESTING
BY EXAMPLE

Namir Sayed-Ahmad Baraza

What's a UNIT?

What's an Unit Test?

A good unit test is:

• Able to be fully automated
• Has full control over all the pieces running
• Can be run in any order if part of many other tests
• Runs in memory (no DB, Network or File access)
• Consistently returns the same result for same input
• Runs fast
• Test a single logical concept in the system
• Readable
• Maintainable
• Trustworthy

So, how to write tests?

Three sentences

• Some output
• Some state changed
• Some function called

A Simple Example!

Our company, Calculator GmbH, needs a brand new feature. A function that allows them to sum 2 numbers!

We are incredible programmers, so we go to our C9 editor, and we write this:

git checkout presentation-unit-testing-sum-step-1

One of your colleages will say:

He shows you how to write the tests. He encourages you to write them before your actual code:

describe('sum', function() {
    it('should sum two numbers and give the result', function () {
        // Given two numbers
        const a = 2;
        const b = 4;
        // When i call sum with them as arguments
        const result = sum(a, b);
        // Then the result should be the sum of both
        expect(result).toBe(6);
    });

    it('should throw an error if any of the arguments is not a number', function () {
        // Given two input, one number and another one which is not a number
        const a = 2;
        const b = '4';
        // When I call sum with them as arguments
        // Then the function should throw an error
        expect(() => { sum(a, b); }).toThrow();
    });

    it('should consider only the value of the inputs not the sign', function () {
        // Given two inputs, one positive number and one negative number
        const a = 2;
        const b = -4;
        // When I call sum with them as arguments
        const result = sum(a, b);
        // Then the result should be the soum of both values ignoring the sign
        expect(result).toBe(6);
    });
});

git checkout presentation-unit-testing-sum-step-2

Don't panic! We can solve it!

git checkout presentation-unit-testing-sum-step-3

For some time, everything was nice but ...

git checkout presentation-unit-testing-sum-step-4

For some time, everything was nice but ... (2)

Runs in memory (no DB, Network or File access)

Don't panic! We can solve it!

Doubles to the rescue!

We have some types of test doubles:

• Fakes (Just for passing arguments)
• Stubs (We use in the test)
• Spies (We want to know if they where called)
• Mocks (Mimic the functionality of the unit it doubles)

So, you have to change your tests

// spyOn OperationLog
// We spy because we want to check if the database was called
beforeEach(function () {
    spyOn(OperationLog, 'insert'); // OperationLog is the Collection
});

// Add one test
it('should log every operation to the database', function () {
     // Given two numbers
    const a = 2;
    const b = 4;
    // When i call sum with them as arguments
    const result = sum(a, b);
    // Then the OperationLog should be updated
    expect(OperationLog.insert).toHaveBeenCalledWith({
        operation: 'sum',
        args: [a, b],
        result
    });
});

git checkout presentation-unit-testing-sum-step-5

And you change the code...

sum = function sum (a, b) {
    // We check the type of the arguments
    if (!Number.isInteger(a) || !Number.isInteger(b)) {
        throw new TypeError('Arguments must be numbers');
    }
    const result = Math.abs(a) + Math.abs(b); // We ignore the sign
    OperationLog.insert({
        operation: 'sum',
        args: [a, b],
        result
    });
    return result;
};

• We need a new method, multiply. it will operate both with integers and floats (positive or negative), but the result should be always rounded.
   
• It should throw an error if any of the arguments is 0
   
• We want to know when each operation was done.  We need a timestamp or something like this.

What have we learnt?

• Testing helps you to write specifications/requirements before starting to code

• Testing helps you to make changes in the code without being scared about breaking it

• Testing allows you to develop features faster, because you don't need to manually test everystep on every reload.

• Testing can help you to write better code

Thanks for listening

Questions time!