Writing and running tests for PHP applications
Creating tests for PHP web applications and applications and maintaining the accuracy and quality of the written program source code is a best practice in PHP programming. PHPUnit is the most widely used framework for testing PHP web or app code, enabling developers to create and write source code unit testing, integration testing, and functional testing. Here is a step-by-step guide for a general user on how to create and run source code for PHP applications.
Setting up PHPUnit in PHP Programming.
Before creating or starting a test in PHP programming, you need to install PHPUnit on your system. Here’s a proper method for installing PHPUnit on your computer using Composer, a feature that allows software developers to manage dependencies in their custom projects.
Install PHPUnit with Composer in PHP.
Install the PHPUnit testing framework globally in the following order.
composer global require phpunit/phpunit
Install PHPUnit for your project in the following order.
composer require –dev phpunit/phpunit
This statement adds the PHPUnit testing framework as a development dependency to your PHP project’s composer.json file.
Verify PHPUnit installation – After PHPUnit is installed on your computer, verify the installation by running the following command statement.
./vendor/bin/phpunit –version
If PHPUnit is properly installed here, this displays the active version of PHPUnit on your computer.
Writing PHPUnit tests.
User-defined PHPUnit tests are typically stored in the tests/ directory in your project. Here, users can create a testing class extending PHPUnit\Framework\TestCase, which should contain methods that test the logic of the user-defined application. PHPUnit framework testing methods generally start with the test prefix in the order indicated.
Example of writing PHPUnit unit tests.
Let’s say we have a user-defined Calculate class, and here we can create testing for its multiply method.
Calculator class (src/Calculat.php) example.
namespace App;
class Calculat
{
public function add($p, $q)
{
return $p + $q;
}
public function subtract($p, $q)
{
return $p – $q;
}
public function multiply($p, $q)
{
return $p * $q;
}
public function divide($p, $q)
{
if ($q == 0) {
throw new \InvalidArgumentException(“Value Division by zero”);
}
return $p / $q;
}
}
Test Class (tests/CalculatTest.php).
namespace Tests;
use PHPUnit\Framework\TestCase;
use App\Calculator;
class CalculatTest extends TestCase
{
private $calculat;
// here we Setup it before to each test
protected function setUp(): void
{
$this->calculat = new Calculat();
}
// here we use it Test for addition
public function testAdd()
{
$output = $this->calculat->add(2, 3);
$this->assertEquals(5, $ output); // Expect 2 + 3 to be 5
}
// here we use Test for subtraction
public function testSubtract()
{
$output = $this->calculat->subtract(7, 3);
$this->assertEquals(4, $ output); // Expect 7 – 3 to be 4
}
// here we use it Test for multiplication
public function testMultiply()
{
$output = $this->calculat->multiply(3, 4);
$this->assertEquals(12, $output); // Expect 3 * 4 to be 12
}
// here we use it Test for division
public function testDivide()
{
$output = $this->calculat->divide(10, 2);
$this->assertEquals(5, $output); // Expect 5 / 10 to be 2
}
// here it Test for division by zero
public function testDivideByZero()
{
$this->expectException(\InvalidArgumentException::class);
$this->calculat->divide(5, 0);
}
}
Here in this example.
- setUp() – This is a user-defined method in the program that runs before each user test. It is used to set up objects or resources.
- testAdd(), testSubtract(), testMultiply(), and testDivide() – These are multiple calculation testing methods that check whether the methods of the Calculate class are running in the proper order.
- assertEquals() – This assertion checks whether the expected value matches the result of the method.
- expectException() – This assertion is used to assert that an exception has been generated during program source code testing, here in the condition of divide by zero.
Running tests in PHPUnit.
After creating user program source code tests, users can run them by applying the PHPUnit command.
Run all PHPUnit tests.
To run all tests in their program source code rigorous testing project, users can run the following command.
./vendor/bin/phpunit
By default, PHPUnit searches for tests in the tests/ directory and searches for classes that extend PHPUnit\Framework\TestCase.
Run tests from a specific file in PHPUnit.
To run tests from a specific file, such as CalculatTest, you can use:
./vendor/bin/phpunit tests/CalculatTest.php
Run tests with specific options in PHPUnit.
Generate a program source code coverage report here.
./vendor/bin/phpunit –coverage-html ./coverage-report
This generates a program source code coverage report in the coverage-report/ directory.
Run tests with detailed output in PHPUnit.
./vendor/bin/phpunit –verbose
Run a specific PHPUnit test method.
Here, users can run a specific test method in a test class by specifying the method name.
./vendor/bin/phpunit tests/CalculatTest.php –filter testAdd
Assertions in PHPUnit.
Assertions in program source code are methods provided by PHPUnit for testing conditions in user program code. Here are some of the most commonly used assertions.
- assertEquals($expected, $actual) – This asserts in program source code that two values are equal.
- assertTrue($condition) – This asserts in program source code that a given condition is true.
- assertFalse($condition) – This asserts in program source code that a given condition is false.
- assertNull($value) – This asserts in program source code that a given value is zero.
- assertNotNull($value) – This asserts in program source code that a given value is not zero.
- assertCount($expectedCount, $array) – This asserts in program source code that an array contains a specified number of elements.
- assertInstanceOf($expectedClass, $object) – This indicates in the program source code that an object is an instance of the indicated class.
- assertGreaterThan($expected, $actual) – This indicates that the realtime value is greater than the expected value.
Organizing PHPUnit tests.
As your project grows from a small project level to a large one, users may need to organize their program source code testing into multiple testing classes and directories.
Test suites – PHPUnit testing allows users to group related tests into testing suites. A testing suite is typically defined in the phpunit.xml configuration file.
Example of phpunit.xml.
<phpunit bootstrap=”vendor/autoload.php”>
<testsuites>
<testsuite name=”Calculat Test Suite”>
<directory>./tests</directory>
</testsuite>
</testsuites>
</phpunit>
This will run all user-defined tests in the configuration tests/ directory for the user.
Mocking and Stubbing in PHPUnit.
Sometimes, when unit testing a user’s source code, they need to isolate parts of the source code that interact with external resources or dependencies, such as databases or web services. Mocks and stubs are used to monitor these dependencies.
Example of mocking a dependency.
Let’s assume that the user has a UserService class that relies on a UserRepository to retrieve users from the current database. You can mock the UserRepository to test the UserService separately.
namespace App;
class UserService
{
private $userRepository;
public function __construct(UserRepository $userRepository)
{
$this->userRepository = $userRepository;
}
public function getUserById($id)
{
return $this->userRepository->find($id);
}
}
Here, in source code testing, you can mock the UserRepository to return a specific result without interacting with the realtime database.
namespace Tests;
use PHPUnit\Framework\TestCase;
use App\UserService;
use App\UserRepository;
class UserServiceTest extends TestCase
{
public function testGetUserById()
{
$mockRepository = $this->createMock(UserRepository::class);
$mockRepository->method(‘find’)->willReturn([‘id’ => 1, ’emp_name’ => ‘Harry Deora’]);
$userService = new UserService($mockRepository);
$user = $userService->getUserById(1);
$this->assertEquals([‘id’ => 1, ’emp_name’ => ‘Harry Deora’], $user);
}
}
Here, the user is mocked by the UserRepository, and the user can be tested independently of the real-time data source.
Test-Driven Development (TDD) with PHPUnit.
Using the PHPUnit testing framework is often done with test-driven development (TDD). The main steps are as follows:
- Write a failing test – Here, users can start by creating a test that explains the expected behaviour of a small part of the capability.
- Write code – Here, users create enough program source code to pass a test.
- Refactor – Here, improve the program source code, ensuring that the test still passes.
- By following these steps, users can ensure that their program source code has been fully tested and behaves in accordance with the expected output.
Steps to get started with PHPUnit.
- First, install PHPUnit on your computer via Composer.
- Write tests by creating test classes that extend PHPUnit\Framework\TestCase.
- Use PHPUnit assertions to verify the program source conditions specified in your program source code.
- Now, run the tests using the PHPUnit command if necessary.
Conclusion on Writing and running tests for PHP applications.
Writing and running tests using PHPUnit in user program source code is an important part of PHP application development. It helps ensure that the user’s program code performs as expected, makes program source code maintenance easier, and provides developers with confidence when refactoring or adding new features. By following these steps, users can thoroughly test their application’s source code and create clear and reliable program source code.
