Building unit tests correctly with visual studio 2013

Building Unit Tests correctly with VS 2013

About.ME

• Senior Consultant @CodeValue

• Developing software (Professionally) since 2002• Mocking code since 2008• Test driven professional

• Blogger: http://blog.drorhelper.com

/* * You may think you know what the following code does. * But you dont. Trust me. * Fiddle with it, and youll spend many a sleepless * night cursing the moment you thought youd be clever * enough to "optimize" the code below. * Now close this file and go play with something else. */ //

// Dear maintainer:// // Once you are done trying to 'optimize' this routine,// and have realized what a terrible mistake that was,// please increment the following counter as a warning// to the next guy:// // total_hours_wasted_here = 42//

//This code sucks, you know it and I know it. //Move on and call me an idiot later.

http://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered

We fear our code!

//Abandon all hope ye who enter beyond this point

//When I wrote this, only God and I understood what I was doing//Now, God only knows

// I dedicate all this code, all my work, to my wife, Darlene, who will // have to support me and our three children and the dog once it gets // released into the public.

//The following 1056 lines of code in this next method //is a line by line port from VB.NET to C#.//I ported this code but did not write the original code.//It remains to me a mystery as to what//the business logic is trying to accomplish here other than to serve as//some sort of a compensation shell game invented by a den of thieves.//Oh well, everyone wants this stuff to work the same as before.//I guess the devil you know is better than the devil you don't.

“If we’re afraid to change the very thing we’ve created, we failed as professionals”Robert C. Martin

Legacy code

“Code without tests is bad code...

With tests, we can change the behavior of our code quickly and verifiably...”

Michael Feathers - “Working effectively with legacy code”

This is a unit test

[Test]public void CheckPassword_ValidUser_ReturnTrue()

{bool result = CheckPassword(“user”,

“pass”);

Assert.That(result, Is.True);}

D

This is also a unit test

[TestMethod]public void CheckPassword_ValidUser_ReturnTrue()

{bool result = CheckPassword(“user”,

“pass”);

Assert.IsTrue(result);}

D

A unit test is…

1. Tests specific functionality

2. Clear pass/fail criteria

3. Good unit test runs in isolation

Unit testing is an iterative effort

Unit testing is an iterative effort

There’s more to unit tests then just “tests”

Written by the developer who wrote the code

Quick feedbackAvoid stupid bugsImmune to regressionChange your code without fearIn code documentation

13 copyright 2008 trainologic LTD13

One last reasonYou’re already Testing your code – manually

So why not save the time?

The cost of unit testing

IBM: Drivers MS: Windows MS: MSN MS: VS0%

20%40%60%80%

100%120%140%

120%135%

115%125%

Time taken to code a feature

WithoutTDD Using TDD

The value of unit testing

IBM: Drivers MS: Windows MS: MSN MS: VS0%

20%40%60%80%

100%120%140%

61%

38%24%

9%

Using Test Driven Design

Time To Code Feature Defect density of team

Major quality improvement for minor time investment

The cost of bugs

Requirements Coding Integration Testing Support0%

20%

40%

60%

80%

100%

010002000300040005000600070008000900010000

Where does it hurt?

% of Defects Introduced Cost to Fix a Defect

% d

efec

ts cr

eate

d

Thou

sand

$s

The pain is here! This is too late…

Supporting environment

• The team

• Development environment

The Team

• The team commitment is important• Learn from test reviews• Track results

Tools of the trade

Server Dev Machine

Source Control

Build Server

Test Runner Code CoverageBuild Script

Unit Testing Framework

Isolation Framework

Development environment

• Make it easy to write and run tests– Unit test framework– Test Runner– Isolation framework

• Know where you stand– Code coverage

Unit testing frameworks

• Create test fixtures• Assert results• Additional utilities• Usually provide command-line/GUI runner

http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks

[Test] public void AddTest() {

var cut = new Calculator(); var result = cut.Add(2, 3);

Assert.AreEqual(5, result); }

This is not a real unit test

Real code has dependencies

Unit test

Code under test

Dependency Dependency

The solution - Mocking

Fake object(s)

Unit test

Code under test

Dependency

Isolation

• Replace production logic with custom logic

• We do this in order to – Focus the test on one class only– Test Interaction– Simplify Unit test writing

What Mocking framework can do for you?

• Create Fake objects

• Set behavior on fake objects

• Verify method was called

• And more...

[Test]public void IsLoginOK_LoggerThrowsException_CallsWebService(){ var fakeLogger = Isolate.Fake.Instance<ILogger>(); Isolate .WhenCalled(() => fakeLogger.Write("")) .WillThrow(new LoggerException()); var fakeWebService = Isolate.Fake.Instance<IWebService>();

var lm = new LoginManagerWithMockAndStub(fakeLogger,fakeWebService); lm.IsLoginOK("", "");

Isolate.Verify.WasCalledWithAnyArguments(() => fakeWebService.Write(""));}

Open source

• FakeItEasy• Moq

• NMock3• nSubtitute

• Rhino Mocks

Free

•MS Fakes

Commercial

• Isolator•JustMoc

k

Moq45%

Rhino Mocks23%

None9%

FakeItEasy6%

Nsubstitute6%

Isolator4%

Moles2%

MS Fakes2%

JustMocks2%

Other 1%

http://osherove.com/blog/2012/5/4/annual-poll-which-isolation-framework-do-you-use-if-any.html

Code Coverage

So, What is a good code coverage?

Source Control

Build Server

Commit

There you go

What’s new?

Build Agents

Start

working

Build ar

tifacts

We automatically get• Error reports &

logs• New version

installer• Help files• More…

Build run at a Glance

How I failed unit testing my codeUn

it tes

ti

ng is great!

Everyth

in

g s

hou

ld

b

e teste

d

I ca

n test “al

mo

st” everyt

hi

ng

Tests b

reak all t

he

ti

me

Unit

testi

ng

is

a

waste

of

ti

me

A good unit test should be:

• Easy to understand• Trustworthy• Robust

Trust Your Tests!

Trustworthy means deterministic

Problem• I cannot re-run the exact same test if a test fails

Solution• Don’t use Random in tests

– If you care about the values set them– If you don’t care about the values put defaults– Do not use Sleep & time related logic – fake it

• Use fake objects to “force” determinism into the test• When possible avoid threading in tests.

Trustworthy also means not fragile

Ideally A test would only fail if a bug was introduced

ORRequirements changed

How to avoid fragile tests

• Don’t test private/internal (most of the time)

• Fake as little as necessary

• Test only one thing (most of the time)

Fragile tests leads to anger. anger leads to hate. hate leads to suffering

Readable unit tests

Unit test intent should be clear!

1.What is being tested?2.What is the desired outcome?3.Why did test fail?

Learn to write “clean tests”

[Test] public void CalculatorSimpleTest() {

calc.ValidOperation = Calculator.Operation.Multiply; calc.ValidType = typeof (int); result = calc.Multiply(1, 3); Assert.IsTrue(result == 3); if (calc.ValidOperation == Calculator.Operation.Invalid) {

throw new Exception("Operation should be valid"); }

}

Or suffer the consequences![Test] public void CalculatorSimpleTest() { var calc = new Calculator(); calc.ValidOperation = Calculator.Operation.Multiply; calc.ValidType = typeof (int); var result = calc.Multiply(-1, 3); Assert.AreEqual(result, -3); calc.ValidOperation = Calculator.Operation.Multiply; calc.ValidType = typeof (int); result = calc.Multiply(1, 3); Assert.IsTrue(result == 3); if (calc.ValidOperation == Calculator.Operation.Invalid) { throw new Exception("Operation should be valid"); } calc.ValidOperation = Calculator.Operation.Multiply; calc.ValidType = typeof (int); result = calc.Multiply(10, 3); Assert.AreEqual(result, 30); }

Writing a good unit test

[Test] public void Multiply_PassTwoPositiveNumbers_ReturnCorrectResult() {

var calculator = CreateMultiplyCalculator();

var result = calculator.Multiply(1, 3);

Assert.AreEqual(result, 3); }

Assert

Act

Arrange

So what about code reuse

Readability is more important than code reuse

• Create objects using factories• Put common and operations in helper

methods• Use inheritance – sparsely

Avoid logic in the test (if, switch etc.)

Problem• Test is not readable• Has several possible paths• High maintain cost

Tests should be deterministic

Solution• Split test to several tests – one for each

path– If logic change it’s easier to update some of the

tests (or delete them)• One Assert per test rule

How to start with unit tests

1. Test what you’re working on – right now!

2. Write tests to reproduce reported bug

3. When refactoring existing code – use unit tests to make sure it still works.

4. Delete obsolete tests (and code)

5. All tests must run as part of CI build