Legacy Dependency Kata v2.0

 Seed Code is written in C#
 Get it from Github:
https://github.com/KatasForLegacyCode/kCSharp/archive/Step0.zip
 Any version of Visual Studio 2012/2013/2015 that can run
console apps and unit tests.
 An nUnit test runner.
 I recommend nCrunch.

Perception - COBOL Reality – Code W/O Unit tests

Code Kata
A code kata is an exercise in
programming which helps a us
hone our skills through practice
and repetition.
The word kata is taken from
Japanese arts most traditionally
Martial Arts
Why a code kata? Because we
learn by doing.

Legacy Dependency Kata: V2.0
 Written in C#
 Less tool dependencies
 Better theme
 Easier to read and follow
 Bug fixes

DoItAllTests.cs
Database.cs
DoItAll.cs
UserDetails.cs
ConsoleAdapter.cs
Program.cs
Logger.cs
Existing Files
We Will
Create

Let’s start by getting the existing test running!
 Running the integration test FAILS
 Begin by abstracting and breaking the dependency on Console.Readline()
 We’ll use an adapter, but we could use the Console.SetIn method and a TextReader.
 Create an interface
public interface IConsoleAdapter
{
string GetInput();
}
 Create a class that implements the
interface & implement method to
handle our dependency
public class ConsoleAdapter : IConsoleAdapter
{
public string GetInput()
{
return Console.ReadLine();
}
}
ConsoleAdapter.cs
ConsoleAdapter.cs
DoItAll.cs
Did you know?
In software engineering,
the adapter pattern is a
software design pattern
that allows the interface
of an existing class to be
used as another
interface.

 Create new constructor to accept IConsoleAdapter & set private variable
private readonly IConsoleAdapter _consoleAdapter;
public DoItAll(IConsoleAdapter consoleAdapter)
{
_consoleAdapter = consoleAdapter;
}
 Replace 4 calls to Console.ReadLine() WITH _consoleAdapter.GetInput()
 Replace 2 calls to Console.ReadKey() WITH _consoleAdapter.GetInput()
DoItAll.cs
DoItAll.cs
DoItAll.cs

We have broken instantiations of DoItAll
 Instantiate and pass in our new handler
var doItAll = new DoItAll(new ConsoleAdapter());
Let’s update our integration test or it will also fail.
 Create a new implementation of IConsoleAdapter
public class DoItAllTests
{
[…]
var doItAll = new DoItAll(new FakeConsoleAdapter());
[…]
}
public class FakeConsoleAdapter : IConsoleAdapter
{
{
return string.Empty;
}
}
Program.cs
DoItAllTests.cs

 When the test is run we now get a meaningful exception. All of the
dependencies that caused the hang are gone.
 the test is now failing because the password is empty. This is a meaningful
case but let’s just update our fake for now.
{
return “someTestString”;
}
 Run the test
AND IT SHOULD BE GREEN!
DoItAllTests.cs

 Following good testing practice,
let’s add an assert:
[Test, Category("Integration")]
public void DoItAll_Does_ItAll()
{
var doItAll = new DoItAll(new FakeConsoleAdapter());
Assert.That(() => doItAll.Do(), Throws.Nothing);
}
 Our test should still pass.
DoItAllTests.cs

Some of our legacy code has no coverage and produces no quantifiable results
 Copy the existing test and rename it DoItAll_Fails_ToWriteToDB
public void DoItAll_Does_ItAll()
{
[…]
}
public void DoItAll_Fails_ToWriteToDB()
{
[…]
}
 Change the assert
Assert.That(doItAll.Do(), Is.StringContaining("Database.SaveToLog Exception:”));
 Build will fail because our Do() method returns void.
DoItAllTests.cs
DoItAllTests.cs

 Change Do()’s return type to string
public string Do()
 Add/update return statements in 3 locations:
public string Do()
{
[…]
if (_userDetails.PasswordEncrypted […])
{
[…]
}
[…]
{
[…]
using (var writer = new StreamWriter("log.txt", true))
{
[…]
}
}
[…]
}
DoItAll.cs
DoItAll.cs

 Now create variables to hold the messages to return
public string Do()
{
[…]
{
var passwordsDontMatch = "The passwords don't match.";
[…]
}
[…]
{
[…]
{
var errorMessage = string.Format("{0} - Database.SaveToLog Exception: rn{1}",
message, ex.Message);
[…]
}
}
[…]
}
DoItAll.cs

 Return the new values as appropriate
public string Do()
{
[…]
{
[…]
Console.WriteLine(passwordsDontMatch);
Console.ReadKey();
return passwordsDontMatch;
}
[…]
{
[…]
{
[…]
writer.WriteLine(errorMessage);
return errorMessage;
}
}
}
 Our new DoItAll_Fails_ToWriteToDB() test should pass
DoItAll.cs

Abstract Console completely
 Add a new method stub
void SetOutput(string output);
 Update ConsoleAdapter implementation
public void SetOutput(string output)
{
Console.WriteLine(output);
}
 Update FakeConsoleAdapter implementation
public void SetOutput(string output)
{}
 Update DoItAll Implementation
Replace 6 instances of Console.WriteLine AND Console.Write WITH
_consoleAdapter.SetOutput
ConsoleAdapter.cs
ConsoleAdapter.cs
DoItAllTests.cs
DoItAll.cs
OUR TESTS SHOULD STILL PASS

DoItAll.Do() is trying to do too much. Let’s Refactor!
 Extract logging functionality by creating a new interface
public interface ILogger
{
string LogMessage(string message);
}
 Create a new class implementing ILogger
public class Logger : ILogger
{
public string LogMessage(string message)
{
throw new NotImplementedException();
}
}
 Now extract the code in the try/catch block in DoItAll.Do() into the implementation of ILogger.LogMessage()
 Make sure all paths return a message
 Now update the constructor of DoItAll with an ILogger AND REPLACE TRY/CATCH:
message = _logger.LogMessage(message);
Logger.cs
Logger.cs

 Extract the code in the try/catch block in DoItAll.Do()
into the implementation of Logger.LogMessage()
Make sure all paths return a message
public string LogMessage(string message)
{
try
{
Database.SaveToLog(message);
}
catch (Exception ex)
{
// If database write fails, write to file
{
message = message + "nDatabase.SaveToLog Exception: " + ex.Message;
writer.WriteLine(message);
}
}
return message;
}
Logger.cs

 Update the constructor of DoItAll with an ILogger
public DoItAll(IOutputInputAdapter ioAdapter, ILogger logger)
{
_ioAdapter = ioAdapter;
_logger = logger;
}
[…]
private readonly ILogger _logger;
 Update the Do() method
public string Do()
{
[…]
_ioAdapter.SetOutput(message);
message = _logger.LogMessage(message);
return message;
}
DoItAll.cs
DoItAll.cs

We have broken instantiations of DoItAll
 Instantiate and pass in our new handler
var doItAll = new DoItAll(new ConsoleAdapter(), new Logger());
Let’s update our tests or they will also fail.
 Create a new implementation of ILogger
public class DoItAllTests
{
[…]
var doItAll = new DoItAll(new FakeConsoleAdapter(), new FakeLogger());
[…]
}
[…]
public class FakeLogger : ILogger
{
public string LogMessage(
string message)
{
}
}
Program.cs
DoItAllTests.cs
OUR FIRST TEST PASSES, BUT THE SECOND FAILS

 Copy the second test and rename the copy
DoItAll_Succeeds_WithMockLogging
 Update the copied assert
Assert.That(doItAll.Do(), Is.EqualTo(string.Empty));
 Let the original test remain an integration test by depending on
Logger and it will pass as well
DoItAllTests.cs
DoItAllTests.cs

There is still plenty to refactor in this legacy code.
 What would you do next?

William Munn, CGFWB
@dubmun
dubmun
http://blog.dubmun.com
Resources
Michael Feathers
Roy Osherove
Robert C. Martin
Dave Thomas & Andy Hunt
Legacy Dependency Kata – V2.0

Legacy Dependency Kata v2.0

More Related Content

What's hot (20)

Similar to Legacy Dependency Kata v2.0 (20)

Recently uploaded (20)

Legacy Dependency Kata v2.0

Editor's Notes