Forem: farhan

Unit tests dos and don'ts

farhan — Sat, 05 Dec 2020 00:04:09 +0000

When writing a unit tests. There are couple of things to do and couple of things which should be avoided. In this article I have listed the dos and don'ts with regards to unit testing.

dos

Test only the public functions.
Test each and every public function. In a ideal world a class should have only one public function and its dependencies.
Mock every dependency.
Test should cover success and failure, both aspects of a code.
Test that every raised exception is tested.
Always specify how many times a function is expected to be called while testing a piece of code.
Test setup pain is a smell, which means your code needs to be refactored.
Code coverage should be 100%, which means each and every line of the tested class was reached.
Live deployment should not work with failing unit tests.
Add tests to classes which are missing unit tests.
Write meaningful names which explain what the test is doing example names testUserRegistrationWasSuccessful, testUserRegistrationWasNotSuccessful, testUserRegistrationRepositoryThrowsException

don'ts

Tested class should never talk to database, file, network resources etc.
Dependencies in tested class should not create real class objects.

http://www.rosenborgsolutions.com/articles/phpunit/phpunit-best-practice

PHPUnit mock function with different values

farhan — Sat, 21 Nov 2020 23:27:51 +0000

When writing unit test, we sometimes mock a function with different
parameter values and expect different return value(s). For example in the popular e-commerce system magento, it's product model class has a getData function. Using this function you can get different attribute(s) of a product.

Function signature

getData($key = '', $index = null)

We wish to get the product color and product size attributes. The code $product->getData('color') should return value "red" and the code $product->getData('size') should return "s". The second parameter $index is null, you can change it to any other value depending on your requirement.

Example mock code

$product = $this->createMock(Product::class);
$product->method('getData')->willReturnMap([
       ['color', null, 'red'],
       ['size', null, 's'],
]);

Learning objectives
Test your php classes
Continuous integration

Prerequisites
Experience with the basics of variables, data types, and running php scripts
Experience setting up PHPUnit, ideally with Composer

Article originally published on http://www.rosenborgsolutions.com/articles/phpunit/phpunit-mock-same-function-with-different-parameters

PHPUnit - How to unit test a method with no return value?

farhan — Mon, 16 Nov 2020 23:09:50 +0000

When writing unit test for one public function in my class. I was a bit confused about how to test a function which has no return value(s). Normally unit tests validate return of boolean value, arrays or some object. There are parts of code which test of Exceptions being thrown from a function. In this scenario I was not throwing any exception or returning a value. What I wanted to test though if certain functionality was executed or not executed when function was being called.

Example code of a function returning void

class UpdateShipmentTracking
{
    private $tracking;

    /**
     * UpdateShipmentTracking constructor.
     * @param Tracking $tracking
     */
    public function __construct(
        Tracking $tracking
    ) {
        $this->tracking = $tracking;
    }

    /**
     * @param array $orders
     */
    public function send(array $orders): void
    {
        /** @var Order $order */
        foreach ($orders as $order) {
            $this->tracking->track($order->getRealOrderId());
        }
    }
}

// @note this class is being mocked in UpdateShipmentTrackingTest
class Tracking
{
    /**
     * @param string $orderID
     */
    public function track(string $orderID): void
    {
        // add shipment tracking number to order
    }
}

Class UpdateShipmentTracking has the following things

It has a constructor injection of class Tracking.
It has a function called send which does not return anything. If array is not empty it updates the shipment tracking number.

How can we test a function like this, to be sure that it is functioning properly? If we observe the code properly there are 2 possibilities that can happen when the send function will be called.

Possibility 1
If we pass empty array to the function. Nothing will be executed. The track function of class Tracking will never be called.

Possibility 2
If we pass 1 element in the array. The track function of class Tracking will be called 1 time.

Now that we can see the possibilities. We can test the 2 scenarios. By doing so we cover that the function returning void is properly tested. If you do not believe my statement the screenshot of code coverage will prove that this is indeed true.

class UpdateShipmentTrackingTest extends TestCase
{
    /** @var Tracking */
    private $tracking;

    protected function setUp(): void
    {
        $this->tracking = $this->createMock(Tracking::class);
    }

    public function testEmptyOrdersArrayIsPassedNothingHappens(): void
    {
        // @note we do not expect function track to be called
        $this->tracking->expects($this->never())
            ->method('track');

        $object = $this->getUpdateShipmentTracking();
        $object->send([]);
    }

    public function testShipmentTrackingNumberWasAdded(): void
    {
        // @note we expect track to be called 1 time, since we pass 1 order
        $this->tracking->expects($this->exactly(1))
            ->method('track');

        $order = $this->createMock(Order::class);

        $order->expects($this->exactly(1))
            ->method('getRealOrderId')
            ->willReturn('100001');

        $object = $this->getUpdateShipmentTracking();
        $object->send([$order]);
    }

    /**
     * @return UpdateShipmentTracking
     */
    private function getUpdateShipmentTracking(): UpdateShipmentTracking
    {
        $objectManager = new ObjectManager($this);

        return $objectManager->getObject(UpdateShipmentTracking::class,
            [
                'tracking' => $this->tracking,
            ]);
    }
}

Article original published on: http://www.rosenborgsolutions.com/articles/phpunit/phpunit-testing-method-return-void