Legacy Code - Testing and Safe Refactoring - Laravel Live UK 2019

@maccath | Katy Ereira | #LaravelLive
Legacy Code.
testing & safe refactoring

View Slide

What is legacy code?
● Code that wasn’t written by you, just now
● Code resulting from incorrect assumptions
● Code built using unsupported technology
● Code that isn’t tested

View Slide

What is refactoring?
● Changing existing code without changing the application logic
● Improving code structure
● Usually done in small, incremental steps

View Slide

Why would I refactor?
● Improve other developer’s understanding
● Increase the application’s performance
● Introduce new technology
● Accommodate changes in product requirements

View Slide

What is unit testing?
● Veriﬁcation that each individual ‘unit’ of an application works as intended
● Units are the component parts of your application
● Generally, each behaviour is a unit; likely to be contained within a function
● Unit testing is not a substitute for other types of testing

View Slide

Why would I unit test?
● Aid in the documentation of the system
● To prevent regressions when adding/changing code
● To test integration with new technology
● For validation of product requirements

View Slide

Paradox: can’t refactor
untested code, but
can’t test the code
until it’s refactored.

View Slide

A solution
1. Rewrite the entire codebase
2. …
3. Proﬁt!
1. Rewrite the entire codebase
2. …
3. Proﬁt!

View Slide

A better solution
1. Perform just enough refactoring to make the code testable
2. Test the code
3. Refactor the code further
4. Proﬁt!

View Slide

Assumptions: you’re developing with PHP
and you have access to a terminal with
Composer.

View Slide

“ PHPUnit is a programmer-oriented testing framework for PHP. It
is an instance of the xUnit architecture for unit testing
frameworks.
PHPUnit
Reference: https:/
/phpunit.de/

View Slide

Create a test using Artisan:
Anatomy of a unit test
$ php artisan make:test ExampleTest --unit

View Slide

Anatomy of a unit test
tests/Unit/ExampleTest.php
namespace Tests\Unit;
use Tests\TestCase;
class ExampleTest extends TestCase
{
public function testSomeFunction()
{
$result = someFunction(); // Should return true
$this->assertTrue($result);
}
}

View Slide

Run your tests:
Running the tests
$ ./vendor/bin/phpunit tests/Unit
PHPUnit by Sebastian Bergmann and contributors.
. 1 / 1 (100%)
Time: 64 ms, Memory: 4.00 MB
OK (1 test, 1 assertion)

View Slide

“
Mockery
Mockery is a simple yet ﬂexible PHP mock object framework for
use in unit testing with PHPUnit, PHPSpec or any other testing
framework.
Reference: https:/
/github.com/mockery/mockery

View Slide

Install via Composer:
$ composer require --dev mockery/mockery
Mockery - Installation

View Slide

Mockery - Usage
class ExampleTest extends PHPUnit\Framework\TestCase
{
public function setUp()
{
$mockObject = Mockery::mock(Object::class); // Mock object.
}
}

View Slide

Mockery - Usage
{
public function setUp()
{
$mockObject = Mockery::mock(Object::class);
$mockObject->shouldReceive('method') // Expectation
->once() // Method called once
->andReturn(true); // Method returns true
}
}

View Slide

Mockery - Usage
{
public function tearDown()
{
Mockery::close(); // Always close after running tests!
}
}

View Slide

Mockery - Usage
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
class ExampleTest extends BaseTestCase
{
}

View Slide

Mocking - Caution!
DO:
● Mock dependencies, when needed.
● Be aware of tautological testing.
DON’T:
● Mock everything.
● Mock the system under test.

View Slide

Disclaimer: the following examples are
deliberately simple.

View Slide

Tricky Test Scenario #1
Output interference

View Slide

A method that echoes

View Slide

myLegacyCode.php
function yodel($tune = null)
{
if ($tune) {
echo $tune; // The yodel is echoed back
} else {
echo 'Odl lay ee'; // A yodel begins
}
}

View Slide

tests/Unit/YodelTest.php
class PrintedOutputTest extends PHPUnit\Framework\TestCase
{
public function testNewYodel()
{
yodel(); // Should echo ‘Odl lay ee’
}
public function testEchoedYodel()
{
yodel('Lay hee hoo'); // Should echo ‘Lay hee hoo’
}
}

View Slide

Run your tests:
$ ./vendor/bin/phpunit tests
PHPUnit 7.5.8 by Sebastian Bergmann and contributors.
ROdl lay eeR 2 / 2 (100%)Lay hee hoo
Time: 60 ms, Memory: 4.00 MB
There were 2 risky tests

View Slide

● Prevent output being echoed to the test runner
● Capture the output that would otherwise be echoed
● Perform assertions on the captured output

View Slide

{
ob_start(); // Start capturing output.
yodel();
}

View Slide

{
ob_start();
yodel();
ob_end_clean(); // Finish capturing output.
}

View Slide

{
ob_start();
yodel();
$output = ob_get_contents(); // Get the output.
ob_end_clean();
}

View Slide

{
ob_start();
yodel();
$output = ob_get_contents();
ob_end_clean();
$this->assertEquals('Odl lay ee', $output); // Success!
}

View Slide

public function testEchoedYodel()
{
ob_start();
yodel('Lay hee hoo');
$output = ob_get_contents();
ob_end_clean();
$this->assertEquals('Lay hee hoo', $output); // Success!
}

View Slide

Hard-coded dependencies

View Slide

A static method call

View Slide

myLegacyCode.php
function getPowerLevel()
{
$result = Goku::powerLevel(); // Goku’s power level is static.
return $result > 9000 ? "It’s over 9000!" : "Suppressed.";
}

View Slide

tests/Unit/PowerLevelTest.php
class PowerLevelTest extends PHPUnit\Framework\TestCase
{
public function testUnder9000()
{
$result = getPowerLevel();
}
public function testOver9000()
{
}
}

View Slide

Goku.php
class Goku
{
static function powerLevel()
{
return 5000; // Always returns 5000.
}
}

View Slide

public function testUnder9000()
{
$this->assertEquals('Suppressed.', $result); // Success!
}

View Slide

{
$this->assertEquals('It’s over 9000!', $result); // Failure.
}

View Slide

● Create a new ‘mock’ of Goku, using a Mockery alias.
● Set the return value of Goku::powerLevel to be 9001.
● Run tests in separate processes.

View Slide

{
$superSaiyanGoku = Mockery::mock('alias:Goku'); // Mock Goku
}

View Slide

{
$superSaiyanGoku = Mockery::mock('alias:Goku')
->shouldReceive('powerLevel') // Set Goku’s power level
->andReturn(9001); // to over 9000. .
}

View Slide

/**
* @runTestsInSeparateProcesses
*/
class PowerLevelTest extends PHPUnit\Framework\TestCase
{
// ...
}

View Slide

{
// Goku is super saiyan!
Mockery::mock('alias:Goku')
->shouldReceive('powerLevel')
->andReturn(9001); .
$this->assertEquals('It’s over 9000!', $result); // Success!
}

View Slide

“
A static method call - via a Facade
Unlike traditional static method calls, facades may be mocked.
This provides a great advantage over traditional static methods
and grants you the same testability you would have if you were
using dependency injection.
Reference: https:/
/laravel.com/docs/5.8/mocking#mocking-facades

View Slide

{
$superSaiyanGoku = Mockery::mock('alias:Goku')
->shouldReceive('powerLevel')
}

View Slide

{
// Goku is super saiyan!
Goku::shouldReceive('powerLevel')
}

View Slide

/**
*/
class PowerLevelTest extends TestCase
{
// ...
}

View Slide

A hard-coded dependency

View Slide

myLegacyCode.php
function getOutlook()
{
$weather = new WeatherForecast(); // A hard-coded dependency.
$outlook = $weather->isSunny() ? "full" : "empty";
return "The glass is half $outlook.";
}

View Slide

WeatherForecast.php
class WeatherForecast
{
static function isSunny()
{
return (bool) rand(0, 1); // Returns random true/false.
}
}

View Slide

tests/Unit/OutlookTest.php
class OutlookTest extends PHPUnit\Framework\TestCase
{
public function testHalfFull()
{
$result = getOutlook();
}
public function testHalfEmpty()
{
}
}

View Slide

{
$this->assertEquals('The glass is half full.', $result);
}

View Slide

{
$this->assertEquals('The glass is half empty.', $result);
}

View Slide

● Mock the WeatherForecast, using a Mockery override.
● Set the return value of WeatherForecast::isSunny to be true or false.
● Perform assertions based on mocked return values.
● Run tests in separate processes.

View Slide

{
}

View Slide

{
$mockForecast = Mockery::mock('overload:WeatherForecast'); // Overload
}

View Slide

{
$mockForecast = Mockery::mock('overload:WeatherForecast')
->shouldReceive('isSunny'); // Set expectation
$this->assertEquals('The glass is half full.', $result); // Success!
}

View Slide

{
->shouldReceive('isSunny')
->andReturn(true); // Force return value true
}

View Slide

{
->andReturn(false); // Force return value false
$this->assertEquals('The glass is half empty.', $result); // Success!
}

View Slide

/**
*/
{
// ...
}

View Slide

● Refactor the code to use an injected dependency.
● Mock the dependency.
● Inject the mocked dependency.
● Remove @runTestsInSeparateProcesses annotation.
Refactoring: hard-coded dependencies

View Slide

myLegacyCode.php
function getOutlook()
{
$weather = new WeatherForecast();
}

View Slide

myLegacyCode.php
function getOutlook(WeatherForecast $weather = null) // Inject
{
$weather = new WeatherForecast();
}

View Slide

myLegacyCode.php
function getOutlook(WeatherForecast $weather = null)
{
$weather = $weather ?? new WeatherForecast(); // Use injected dependency
}

View Slide

tests\OutlookTest.php
{
->andReturn(true);
}

View Slide

{
$mockForecast = Mockery::mock(WeatherForecast::class) // No overload!
->andReturn(true);
}

View Slide

{
$mockForecast = Mockery::mock(WeatherForecast::class)
->andReturn(true);
$result = getOutlook($mockForecast); // Inject!
}

View Slide

/**
*/
{
// ...
}

View Slide

Ungraceful exits

View Slide

Redirections

View Slide

myLegacyCode.php
function getMeOutOfHere(bool $imACelebrity = false)
{
if ($imACelebrity) {
header('Location: http://google.com');
}
return "Nope!";
}
Redirections

View Slide

tests/Unit/GetMeOutTest.php
class GetMeOutTest extends PHPUnit\Framework\TestCase
{
public function testLeaveMeHere()
{
getMeOutOfHere();
}
public function testGetMeOut()
{
getMeOutOfHere($imACelebrity = true);
}
}
Redirections

View Slide

/**
*/
class GetMeOutTest extends PHPUnit\Framework\TestCase
{
public function testLeaveMeHere() { … }
public function testGetMeOut() { … }
}
Redirections

View Slide

public function testLeaveMeHere()
{
$result = getMeOutOfHere();
$this->assertEquals('Nope!', $result); // Success!
}
Redirections

View Slide

{
$result = getMeOutOfHere($imACelebrity = true);
$this->assertNotEquals('Nope!', $result); // Failure.
}
Redirections

View Slide

Refactoring: Redirections
● Return/continue/break after (potentially) redirecting.
or
● Set redirection header as the very last step.

View Slide

myLegacyCode.php
{
if ($imACelebrity) {
return; // Don’t go any further!
}
return "Nope!";
}
Redirections

View Slide

myLegacyCode.php
{
if (!$imACelebrity) {
return "Nope!"; // Return early.
}
}
Redirections

View Slide

{
$result = getMeOutOfHere($imACelebrity = true);
$this->assertNotEquals('Nope!', $result); // Success!
}
Redirections

View Slide

Exiting

View Slide

myLegacyCode.php
function brexit(bool $remoaner = false)
{
if ($remoaner) {
return 'People’s vote!';
}
exit;
}
Exiting

View Slide

tests/Unit/BrexitTest.php
class BrexitTest extends PHPUnit\Framework\TestCase
{
public function testBrexit()
{
$result = brexit();
}
public function testRemoaner()
{
$result = brexit($remoaner = true);
}
}
Exiting

View Slide

public function testRemoaner()
{
$result = brexit($remoaner = true);
$this->assertEquals('People’s vote!', $result); // Success!
}
Exiting

View Slide

{
$result = brexit();
$this->assertEmpty($result); // Never gets here.
}
Exiting

View Slide

Refactoring: Exiting
● Create a wrapper around the exit functionality.
● Inject the exit wrapper.
● Safely refactor to use the exit wrapper.
● Mock the exit wrapper.

View Slide

BrexitUtility.php
class BrexitUtility
{
public function brexitMeansBrexit()
{
exit; // Completely exits.
}
}
Exiting

View Slide

myLegacyCode.php
function brexit(bool $remoaner, BrexitUtility $brexitUtil = null) // Inject
{
if ($remoaner) { … }
exit;
}
Exiting

View Slide

myLegacyCode.php
function brexit(bool $remoaner, BrexitUtility $brexitUtil = null)
{
$brexitUtil = $brexitUtil ?? new BrexitUtility(); // Set default.
exit;
}
Exiting

View Slide

myLegacyCode.php
function brexit(bool $remoaner, BrexitUtility $brexitUtil = null)
{
$brexitUtil = $brexitUtil ?? new BrexitUtility();
$brexitUtil->brexitMeansBrexit(); // Use the brexit utility.
}
Exiting

View Slide

{
$mockBrexitUtil = Mockery::mock(BrexitUtility::class); // Mock Brexit util
$result = brexit();
$this->assertNotEquals('People’s vote!', $result); // Failure.
}
Exiting

View Slide

{
$mockBrexitUtil = Mockery::mock(BrexitUtility::class)
->shouldIgnoreMissing(); // Do nothing...
$result = brexit();
$this->assertNotEquals('People’s vote!', $result); // Failure.
}
Exiting

View Slide

{
->shouldIgnoreMissing();
$result = brexit($remoaner = false, $mockBrexitUtil); // Use it.
$this->assertNotEquals('People’s vote!', $result); // Success!
}
Exiting

View Slide

{
->shouldIgnoreMissing();
$result = brexit($remoaner = false, $mockBrexitUtil);
$this->assertNotEquals('People’s vote!', $result); // Success!
}
Exiting

View Slide

The ﬁlesystem

View Slide

Filesystem

View Slide

myLegacyCode.php
function countHit()
{
$count = file_get_contents(__DIR__ . '/hit_counter.txt');
file_put_contents(__DIR__ . '/hit_counter.txt', ++$count);
}
Updating a ﬁle

View Slide

tests/Unit/HitCounterTest.php
class HitCounterTest extends PHPUnit\Framework\TestCase
{
public function testCountsHit()
{
countHit();
}
}
Updating a ﬁle

View Slide

{
$hitCounterFile = __DIR__ . '/../hit_counter.txt';
$countBefore = file_get_contents($hitCounterFile);
countHit();
$countAfter = file_get_contents($hitCounterFile);
$this->assertEquals($countBefore++, $countAfter); // Success!
}
Updating a ﬁle

View Slide

Refactoring: Updating a file
● Inject the filename.
● Create a test hit counter file.
● Reset the file contents after each test.

View Slide

myLegacyCode.php
function countHit()
{
}
Updating a ﬁle

View Slide

myLegacyCode.php
function countHit($file = __DIR__ . '/hit_counter.txt') // Inject $file
{
}
Updating a ﬁle

View Slide

myLegacyCode.php
function countHit($file = __DIR__ . '/hit_counter.txt') // Inject $file
{
$count = file_get_contents($file); // Use $file
file_put_contents($file, ++$count); // Use $file
}
Updating a ﬁle

View Slide

{
$hitCounterFile = __DIR__ . '/hit_counter.txt';
countHit();
$this->assertEquals($countBefore++, $countAfter);
}
Updating a ﬁle

View Slide

{
$hitCounterFile = __DIR__ . '/test_hit_counter.txt'; // Test file!
countHit();
}
Updating a ﬁle

View Slide

{
$hitCounterFile = __DIR__ . '/test_hit_counter.txt';
countHit($hitCounterFile); // Use test hit counter file.
}
Updating a ﬁle

View Slide

{
file_put_contents($hitCounterFile, 0); // Reset counter.
}
Updating a ﬁle

View Slide

“ vfsStream is a stream wrapper for a virtual file system that may
be helpful in unit tests to mock the real file system. It can be used
with any unit test framework, like PHPUnit or SimpleTest.
Fake filesystem
Reference: http:/
/vfs.bovigo.org/

View Slide

{
countHit($hitCounterFile);
}
Fake ﬁlesystem

View Slide

{
$vfs = vfsStream::setup();
$hitCounterFile = vfsStream::newFile('test_hit_counter.txt')
->at($vfs)
->setContent('0');
countHit($hitCounterFile->url());
$this->assertEquals(1, $hitCounterFile->getContent());
}
Fake ﬁlesystem

View Slide

{
file_put_contents($hitCounterFile, 0); // Reset counter.
}
Fake ﬁlesystem

View Slide

Spaghetti code

View Slide

Spaghetti code
src\Bolognese.php
class Bolognese
{
private $eaten;
private $parmesan;
public function __construct(bool $eaten = false) { … }
public function eat() { … }
public function isEaten(): bool { … }
}

View Slide

Spaghetti code
src\Bolognese.php
public function eat()
{
if ($this->eaten) return; // Can’t eat twice!
if (!$this->parmesan || !$this->parmesan->isEaten()) {
$this->parmesan = new Parmesan(); // Must always have parmesan.
}
(new GarlicBread())->eat(); // Gotta have garlic bread.
$this->parmesan->eat();
$this->eaten = true;
}

View Slide

tests/Unit/BologneseTest.php
class BologneseTest extends PHPUnit\Framework\TestCase
{
public function testEat()
{
$bolognese = new Bolognese();
$bolognese->eat();
}
}
Spaghetti code

View Slide

{
$bolognese->eat();
$this->assertTrue($bolognese->isEaten());
}
Spaghetti code

View Slide

Testing: Spaghetti Code
● Use @covers annotation to isolate unit under test
● Create reusable expectations:
○ to illustrate diﬀerent scenarios
○ to deﬁne alternate process branches

View Slide

/**
* @covers Bolognese
*/
{
$bolognese->eat();
$this->assertTrue($bolognese->isEaten());
}

View Slide

public function testEatDevouredBolognese() { … }
public function testEatUneatenBolognese() { … }

View Slide

private function eatenBolognese()
{
return new Bolognese($eaten = true);
}
private function uneatenBolognese()
{
return new Bolognese($eaten = false);
}

View Slide

private function expectGarlicBreadToBeEaten()
{
$garlicBread = Mockery::mock('overload:GarlicBread');
return $garlicBread->shouldReceive('eat'); // Return expectation.
}

View Slide

public function testEatDevouredBolognese()
{
$this->expectGarlicBreadToBeEaten()->never();
$this->eatenBolognese()->eat();
}
public function testEatUneatenBolognese()
{
$this->expectGarlicBreadToBeEaten()->once();
$this->uneatenBolognese()->eat();
}

View Slide

Tricky Test Scenario Group #6
Private methods

View Slide

Private methods

View Slide

Private methods
MCHammer.php
class MCHammer
{
public function stop()
{
return $this->cantTouchThis();
}
private function cantTouchThis()
{
return 'hammertime';
}
}

View Slide

Private methods
tests/Unit/MCHammerTest.php
class MCHammerTest extends PHPUnit\Framework\TestCase
{
public function testCantTouchThis()
{
$mcHammer = new MCHammer();
$result = $mcHammer->cantTouchThis(); // Error; private method!
$this->assertEquals('hammertime', $result);
}
}

View Slide

Private methods
● Don’t test private methods.
● Test the public methods that use private methods.
● Private methods represent implementation details.
● Private methods should remain invisible.

View Slide

Private methods
{
{
$result = $mcHammer->stop(); // Public method!
$this->assertEquals('hammertime', $result);
}
}

View Slide

Private methods
{
{
$result = $mcHammer->stop();
$this->assertEquals('hammertime', $result); // Success!
}
}

View Slide

Thank you!
Feedback welcome! https:/
/joind.in/talk/718c8

View Slide

Legacy Code - Testing and Safe Refactoring - Laravel Live UK 2019

Legacy Code - Testing and Safe Refactoring - Laravel Live UK 2019

Katy Ereira

More Decks by Katy Ereira

Other Decks in Programming

Featured

Transcript