Legacy Code - Testing and Safe Refactoring - Scotland PHP 2019

@maccath | Katy Ereira | #ScotPHP19
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?
● Updating 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

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 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

I’m still on PHP version 5.6 / 7.0 / 7.1 !
PHPUnit Version PHP Version Requirement Supported Until
9 7.3 Future release
8 7.2 February 5, 2021
7 7.1 February 7, 2020
6 7.0 [unsupported] February 8, 2019
5 5.6 [unsupported] February 2, 2018

View Slide

Install via Composer:
PHPUnit - installation
$ composer require --dev phpunit/phpunit ^|version|
$ ./vendor/bin/phpunit --version
PHPUnit x.y.z by Sebastian Bergmann and contributors.

View Slide

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

View Slide

Run your tests:
Running the tests
$ ./vendor/bin/phpunit tests
PHPUnit 7.5.8 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
tests/Unit/ExampleTest.php
{
public function setUp(): void
{
$mockObject = Mockery::mock(Object::class);
}
}

View Slide

Mockery - Usage
{
public function setUp(): void
{
$mockObject = Mockery::mock(Object::class);
$mockObject->shouldReceive('method') // Expect that ‘method’
->once() // should be called once
->andReturn(true); // and return true
}
}

View Slide

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

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
Interfering Output

View Slide


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
}
}
A method that echoes

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

Tricky Test Scenario #2a
Static method calls

View Slide


View Slide

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

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


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

Tricky Test Scenario #2b
Making new objects on the ﬂy

View Slide


View Slide

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

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

Tricky Test Scenario #3a
Redirects

View Slide


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

Tricky Test Scenario #3b
Exiting

View Slide


View Slide

myLegacyCode.php
function brexit(bool $remainer = false)
{
if ($remainer) {
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 testRemainer()
{
$result = brexit($remainer = true);
}
}
Exiting

View Slide

public function testRemainer()
{
$result = brexit($remainer = 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

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

View Slide

myLegacyCode.php
function brexit(bool $remainer, Boris $boris = null) // Inject
{
if ($remainer) { … }
exit;
}
Exiting

View Slide

myLegacyCode.php
function brexit(bool $remainer, Boris $boris = null)
{
$boris = $boris ?? new Boris(); // Set default.
if ($remoaner) { … }
exit;
}
Exiting

View Slide

myLegacyCode.php
function brexit(bool $remainer, Boris $boris = null)
{
$boris = $boris ?? new Boris();
if ($remainer) { … }
$boris->brexitMeansBrexit(); // Be Boris.
}
Exiting

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

The ﬁlesystem

View Slide


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


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


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 ye!

View Slide

Legacy Code - Testing and Safe Refactoring - Scotland PHP 2019

Legacy Code - Testing and Safe Refactoring - Scotland PHP 2019

Katy Ereira

More Decks by Katy Ereira

Other Decks in Programming

Featured

Transcript