Legacy Code - Longhorn PHP 2022

@maccath | Katy Ereira | #LonghornPHP
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. Lather, rinse, repeat.
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

@maccath | Katy Ereira | #ScotPHP19
I’m still on PHP version 5.6 / 7.0 / 7.1 !
PHPUnit Version PHP Version Requirement Supported Until
10 8.1 Future release
9 >= 7.3 February 2, 2024
8 >= 7.2 February 3, 2023
7 7.1, 7.2, 7.3 February 7, 2020
6 7.0, 7.1, 7.2 February 8, 2019
5 5.6, 7.0, 7.1 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

Mocking
● Create test doubles
● Verify the behaviour of your code
● Isolate the system under test

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

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

Disclaimer: the following examples are
deliberately simple.

View Slide

Tricky Test Scenario #1
Interfering Output

View Slide


View Slide

hillsAreAlive.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/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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

tests/YodelTest.php
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

Static method calls

View Slide


View Slide

Vegeta.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/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

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

View Slide


View Slide

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

View Slide

Hard-coded dependencies

View Slide


View Slide

PessimistOrOptimist.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/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

Testing: hard-coded dependencies
● 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

/**
* @preserveGlobalState disabled
*/
{
// ...
}

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

{
->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 #4 (a)
Redirects

View Slide


View Slide

holyGrail.php
function enterCaveOfCaerbannog(bool $killerRabbit = false)
{
if ($killerRabbit) {
header('Location: http://www.montypython.com');
}
return "Behold!";
}
Redirections

View Slide

tests/CaveOfCaerbannogTest.php
class EnterCaveOfCaerbannogTest extends PHPUnit\Framework\TestCase
{
public function testEnterSafely()
{
enterCaveOfCaerbannog();
}
public function testRunAway()
{
enterCaveOfCaerbannog($killerRabbit = true);
}
}
Redirections

View Slide

/**
*/
class EnterCaveOfCaerbannogTest extends PHPUnit\Framework\TestCase
{
public function testEnterSafely() { … }
public function testRunAway() { … }
}
Redirections

View Slide

public function testEnterSafely()
{
$result = enterCaveOfCaerbannog();
$this->assertEquals('Behold!', $result); // Success!
}
Redirections

View Slide

{
$result = enterCaveOfCaerbannog($killerRabbit = true);
$this->assertNotEquals('Behold!', $result); // Failure.
}
Redirections

View Slide

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

View Slide

holyGrail.php
{
if ($killerRabbit) {
return; // Go no further!
}
return "Behold!";
}
Redirections

View Slide

holyGrail.php
{
if (!$killerRabbit) {
return "Behold!"; // Return early.
}
}
Redirections

View Slide

{
$result = enterCaveOfCaerbannog($killerRabbit = true);
$this->assertEmpty($result); // Success!
}
Redirections

View Slide

Tricky Test Scenario #4 (b)
Exiting

View Slide


View Slide

LizTruss.php
function lizTruss(bool $quitter = false)
{
if (!$quitter) {
return 'I am a fighter, not a quitter!';
}
exit;
}
Exiting

View Slide

tests/LizTrussTest.php
class LizTest extends PHPUnit\Framework\TestCase
{
public function testNotAQuitter()
{
$result = lizTruss($quitter = false);
}
public function testIsAQuitter()
{
$result = lizTruss($quitter = true);
}
}
Exiting

View Slide

public function testNotAQuitter()
{
$result = lizTruss($quitter = false);
$this->assertEquals('I am a fighter, not a quitter!', $result);
}
Exiting

View Slide

{
$this->assertEmpty($result); // We never get 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

DowningStreet.php
class DowningStreet
{
public function leave()
{
exit; // Leave the building.
}
}
Exiting

View Slide

LizTruss.php
function lizTruss(bool $quitter = false, DowningStreet $no10 = null) // Inject
{
if (!$quitter) { … }
exit;
}
Exiting

View Slide

LizTruss.php
function lizTruss(bool $quitter = false, DowningStreet $no10 = null)
{
$no10 = $no10 ?? new DowningStreet(); // Set default.
exit;
}
Exiting

View Slide

LizTruss.php
function lizTruss(bool $quitter = false, DowningStreet $downingSt = null)
{
$no10 = $no10 ?? new DowningStreet();
$no10->leave(); // Leave.
}
Exiting

View Slide

{
$no10 = Mockery::mock(DowningStreet::class); // Mock no10.
$this->assertEmpty($result); // Failure.
}
Exiting

View Slide

LizTruss.php
public function testLizTruss()
{
$no10 = Mockery::mock(DowningStreet::class)
->shouldIgnoreMissing(); // Do nothing...
$this->assertEmpty($result); // Failure.
}
Exiting

View Slide

public function testLizTruss()
{
$no10 = Mockery::mock(DowningStreet::class)
->shouldIgnoreMissing();
$result = lizTruss($quitter = true, $no10);
$this->assertEmpty($result); // Success!
}
Exiting

View Slide

Filesystem interaction

View Slide


View Slide

HitCounter.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/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 double hit counter file.
● Reset the file contents after each test.

View Slide

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

View Slide

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

View Slide

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

tests/Unit/HitCounterTest.php
{
$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
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
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/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

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

Time for a recap...
● Interfering output
● Static methods
● Hard-coded dependencies
● Ungraceful exits
● Filesystem interaction
● Spaghetti code
● Private methods

View Slide

https://joind.in/talk/e0655

View Slide

Legacy Code - Longhorn PHP 2022

Legacy Code - Longhorn PHP 2022

Katy Ereira

More Decks by Katy Ereira

Other Decks in Programming

Featured

Transcript