How To Generate PHPUnit Coverage Report In HTML and XML?

Demonstration – Generation of code coverage report in PHP

The php-code-coverage module, an extension of PHPUnit, can use XDebug or PCOV, which facilitates code coverage functionality. For demonstrating the usage of php-code-coverage for code coverage analysis and reporting, we consider two test scenarios that are executed against different browsers (and OS combinations).

The test scenarios are tested on a local Selenium Grid installed on our Windows 10 machine. We have used Selenium Grid 3 (i.e., 3.141.59) for performing the tests. You can use the following command to start the Selenium Grid server:

java -jar selenium-server-standalone-3.141.59.jar

Here are the test scenarios:

Test Scenario – 1 (Browser – Chrome, Platform – Windows 10)

• Navigate to the URL https://lambdatest.github.io/sample-todo-app/
• Select the first two checkboxes
• Send ‘Yey, Lets add it to list’ to the textbox with id = sampletodotext
• Click the Add Button and verify whether the text has been added or not
• Assert if the title does not match with the expected window title

Test Scenario – 2 (Browser – Firefox, Platform – Windows 10)

• Navigate to the URL https://www.google.com/ncr
• Locate the Search text box
• Enter ‘TestMu AI’ in the search box
• Click on the search button and assert if the title does not match with the expected window title

Directory Structure

We create separate ‘src’ and ‘tests’ folders where:

• src 🡪 Contains two PHP files (i.e., Search.php and Todos.php) that include the methods which will be used by the test files.
• tests 🡪 Contain test files (i.e., ChromeTodoTest.php and FirefoxSearchTest.php) stored in browser-specific folders (i.e., Chrome and Firefox), respectively.

Apart from these folders, composer.json, and phpunit.xml.dist are kept in the parent folder. Here is the overall folder structure:

Figure 2 Parent Folder Structure

Figure 3 Parent Folder Structure

Figure 4 Parent Folder Structure

Implementation

a. composer.json

The first step is the creation of composer.json in the root project folder for downloading the dependencies for the Selenium PHP project under development.

{
   "require":{
     "php":">=7.1",
     "phpunit/phpunit-selenium": "*",
     "php-webdriver/webdriver":"1.8.0",
     "symfony/symfony":"4.4",
     "brianium/paratest": "dev-master"
   },
   "require-dev": {
      "phpunit/php-code-coverage": "^9.1",
      "phpunit/phpunit": "^9.3",
      "pcov/clobber": "^2.0"
   }
}

For validating the format of JSON can be validated by going to JSON Lint. Below are the projected dependencies that are listed in composer.json:

• PHP (version 7.1 or above)
• PHPUnit (version 9 or above)
• PHPUnit-selenium (latest version)
• PHP-WebDriver (version 1.8.0) – Selenium WebDriver library for automation with Selenium PHP
• Symphony (version 4.4) – Set of reusable PHP components and a PHP framework for building web applications, APIs, and microservices.
• phpunit/php-code-coverage (version 9.3 and above)
• pcov/clobber (version 2.0 and above)

For installing the dependencies mentioned in composer.json, run the command composer.require on the terminal and press Enter twice to proceed with the installation of the specified packages:

composer require

Here is the screenshot of the terminal:

Upon completing the command execution, the file composer.lock and folder ‘vendor’ would be created in the project folder. Vendor contains all the downloaded packages and composer.lock contains detailed information on the dependencies.

Figure 5 Creation of vendor and composer.lock

Figure 6 php-code-coverage created by composer.json

Figure 7autoload.php in the vendor folder

As seen above, the composer module has generated a vendor\autoload.php file. The file should be included in the PHP files that contain the test implementation so that the classes provided by those libraries can be used without putting extra efforts (in the code).

b. src\ Todos.php

<?php
 
use PHPUnitFrameworkTestCase;
use FacebookWebDriverRemoteDesiredCapabilities;
use FacebookWebDriverRemoteRemoteWebDriver;
use FacebookWebDriverWebDriverBy;
 
class Todos
{
    private $session;
  /* Sample-ToDoText ID */
    public $input;
 
    public function __construct($session)
    {
      $this->session = $session;
      $this->input = $session->findElement(WebDriverBy::id("addbutton"));
    }
 
    public function ToggleLi1()
    {
      $element1 = $this->session->findElement(WebDriverBy::name("li1"));
      $element1->click();
    }
 
    public function ToggleLi2()
    {
      $element2 = $this->session->findElement(WebDriverBy::name("li2"));
      $element2->click();
    }
 
  public function addTodo($itemName)
  {
    $element = $this->session->findElement(WebDriverBy::id("sampletodotext"));
    $element->click();
    $element->sendKeys($itemName . "
");
  }
}

Here is the code walkthrough of the essential parts in the implementation:

• The __construct() method is implemented, which is used to initialize the object’s properties upon the creation of the object. The $session variable is used in all the methods.

public function __construct($session)
{
	$this->session = $session;
      $this->input = $session->findElement(WebDriverBy::id("addbutton"));
}

• Based on the requirements of the test scenario, appropriate methods are created which would be further used in the test code.

  In ToggleLi1, the web element with the name ‘li1’ on https://lambdatest.github.io/sample-todo-app/ is located, and the a ‘click’ operation is performed. The methods are created based on the assumption that the ToDo app on TestMu AI is used as the web page under test.

  The Inspect tool in the Chrome browser is used for getting information about the web element.

public function ToggleLi1()
{
      $element1 = $this->session->findElement(WebDriverBy::name("li1"));
      $element1->click();
}

The same set of operations are also performed for elements with the name ‘li2’. For adding a new item in the ToDo list, the text box with ID ‘sampletodotext’ is located, and the sendKeys() method in Selenium is invoked for adding the new item in the list.

We used the POM Builder extension in Chrome to get details of the web element on the page.

public function addTodo($itemName)
{
    $element = $this->session->findElement(WebDriverBy::id("sampletodotext"));
    $element->click();
    $element->sendKeys($itemName . "
");
}

c. src\ Search.php

<?php
 
use FacebookWebDriverWebDriverBy;
 
class Search
{
    private $session;
    public $input;
 
    public function __construct($session)
    {
        $this->session = $session;
        $this->input = $session->findElement(WebDriverBy::name("q"));
    }
 
    public function SearchonGoogle($search_string)
    {
        $element = $this->session->findElement(WebDriverBy::name("q"));
        $element->click();
        if($element) {
          $element->sendKeys($search_string);
          $element->submit();
        }
    }
    
    public function ClickSearchResult()
    {
        $element = $this->session->findElement(WebDriverBy::xpath("//h3[.='LambdaTest: Most Powerful Cross Browser Testing Tool Online']"));
        sleep(2);
        if($element) {
          $element->click();
        }
    }
}

Here is the code walkthrough of the important parts of the implementation:

• The $session variable is used in the __construct function (or constructor), which is the ideal way for storing information (in variables) that would be used across multiple pages.

public function __construct($session)
{
	$this->session = $session;
	$this->input = $session->findElement(WebDriverBy::name("q"));
}

• Search box on the Google home-page is located using the ‘name’ property. The sendKeys Selenium method with input argument as ‘search string’ (which is passed from the test method) is used against the located web element.


public function SearchonGoogle($search_string)
{
	$element = $this->session->findElement(WebDriverBy::name("q"));
	$element->click();
	if($element) {
	   $element->sendKeys($search_string);
         $element->submit();
      }
}

• In the ClickSearchResult method, the link with XPath as “//h3[.=’TestMu AI: Most Powerful Cross Browser Testing Tool Online’]” is located, and a click operation is performed.


public function ClickSearchResult()
{
        $element = $this->session->findElement(WebDriverBy::xpath("//h3[.='LambdaTest: Most Powerful Cross Browser Testing Tool Online']"));
        sleep(2);
        if($element) {
          $element->click();
        }
}

d. tests\ ChromeTodoTest.php

<?php 
 
require 'vendor/autoload.php';
require 'src/Todos.php';
 
use PHPUnitFrameworkTestCase;
use FacebookWebDriverRemoteDesiredCapabilities;
use FacebookWebDriverRemoteRemoteWebDriver;
use FacebookWebDriverWebDriverBy;
 
use SebastianBergmannCodeCoverageCodeCoverage;
use SebastianBergmannCodeCoverageDriverDriver;
use SebastianBergmannCodeCoverageFilter;
use SebastianBergmannCodeCoverageReportHtmlFacade as HtmlReport;
 
$filter = new Filter;
$filter->includeFile('location-to-pathTodos.php');
$driver = Driver::forLineCoverage($filter);
$coverage = new CodeCoverage($driver, $filter);
 
$condition_comp = true;
 
class ChromeTodoTest extends TestCase
{
    protected $todos;
    protected $webDriver;
    
    protected function setUp(): void
    {
        global $condition_comp;
        if ($condition_comp == true) {
            global $filter;
            global $driver;
            global $coverage;
        }
        $this->webDriver = RemoteWebDriver::create('http://localhost:4444/wd/hub', DesiredCapabilities::chrome());
        $this->webDriver->get('https://lambdatest.github.io/sample-todo-app/');
        $this->webDriver->manage()->window()->maximize();
        $this->todos = new Todos($this->webDriver);
        print("Called");
    }
    
    /**
     * @covers Todos::ToggleLi1
     */
    public function testClickli1()
    {
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testClickli1');
        }
        $this->todos->ToggleLi1();
        sleep(5);
        $this->assertEquals('Sample page - lambdatest.com', $this->webDriver->getTitle());
        if ($condition_comp == true) {
            $coverage->stop();
        }
    }
    
    /**
     * @covers Todos::ToggleLi2
     */
    
    public function testClickli2()
    {
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testClickli2');
        }
        $this->todos->ToggleLi2();
        sleep(5);
        $this->assertEquals('Sample page - lambdatest.com', $this->webDriver->getTitle());
        if ($condition_comp == true) {
            $coverage->stop();
        }
    }
    
    /**
     * @covers Todos::addTodo
     */
    public function testAddToList()
    {
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testAddToList');
        }
        $itemName = 'Yey, Lets add it to list';
        $this->todos->addTodo($itemName);
        $this->webDriver->wait(10, 500)->until(function($driver) {
          $elements = $this->webDriver->findElements(WebDriverBy::cssSelector("[class='list-unstyled'] li:nth-child(6) span"));
          return count($elements) > 0;
        });
        sleep(5);
        $this->assertEquals('Sample page - lambdatest.com', $this->webDriver->getTitle());
        if ($condition_comp == true) {
            $coverage->stop();
            (new HtmlReport)->process($coverage, 'code-coverage-report
eport');
        }
    }
    
    public function tearDown(): void
    {
        $this->webDriver->quit();
    }
}

Here is the code walkthrough that deep dives into the test code’s essential parts (used for running Test Scenario-1).

• Apart from importing classes and functions related to RemoteWebDriver, we import the classes related to the CodeCoverage module.
• A new filter object is created and the includeFile() method of the Filter class is used for limiting the code coverage to the concerned PHP file (i.e. ToDos.php)

$filter = new Filter;
$filter->includeFile('absolute-path-toTodos.php');

• A new Driver object is created, and its method forLineCoverage() is applied on the filter object (i.e., Code coverage analysis will be based on line-coverage, and the ToDos.php is the file against which the coverage is calculated).

  The CodeCoverage object is created, with driver and filter objects as the arguments.

$driver = Driver::forLineCoverage($filter);
$coverage = new CodeCoverage($driver, $filter);

• A global Boolean variable named ‘condition_comp’ is created, and it is set to true. The variable has other usage, as code coverage across the files can also be calculated without php-unit-coverage in the test code.

  We would touch upon that aspect in subsequent sections.

$condition_comp = true;

• The test case ‘ChromeTodoTest’ extends the TestCase class, a part of the PHPUnit\Framework\TestCase package.

class ChromeTodoTest extends TestCase

• The setUp() method contains the initialization related implementation regarding Selenium PHP automation.

  The create method of RemoteWebDriver class is used for creating a new instance of the Chrome browser. The first argument of the method is the Selenium server address that has to be started before the tests are executed. In our case, the Selenium server is listening on port 4444 for any incoming requests (i.e., http://localhost:4444/wd/hub).

protected function setUp(): void
{
	global $condition_comp;
	if ($condition_comp == true) {
		global $filter;
            global $driver;
            global $coverage;
      }
        $this->webDriver = RemoteWebDriver::create('http://localhost:4444/wd/hub', DesiredCapabilities::chrome());
        .................................................
	  .................................................
    }

• The get method of RemoteWebDriver class is used for setting the target URL i.e. https://lambdatest.github.io/sample-todo-app/

A new object (i.e. todos) of Todos class is created with an input parameter as the webdriver object.

$this->webDriver->get('https://lambdatest.github.io/sample-todo-app/');
.................................................
.................................................
$this->todos = new Todos($this->webDriver);

• The test case testClickli1() tests the ToggleLi1() method (of Todos class). The start method of the $coverage object is invoked for starting the PHPUnit coverage report in HTML. The stop method of the $coverage object is invoked to stop the PHPUnit code coverage report for testClickli1().

public function testClickli1()
{
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testClickli1');
        }
        $this->todos->ToggleLi1();
        .................................................
	  .................................................
        if ($condition_comp == true) {
            $coverage->stop();
        }
    }

• For every test case, the start() method of the coverage object is invoked to trigger the start of code coverage, and the stop() method is used for stopping the coverage for the particular test case.

  In this test case, a non-blocking wait of 10 seconds is performed using wait(10,500), where the presence of the required web element is checked at a 500ms duration. The required web element count should return a non-zero value if that particular web element (i.e., Yey, Lets add it to list’) is present on the page.

/**
     * @covers Todos::addTodo
     */
    public function testAddToList()
    {
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testAddToList');
        }
        $itemName = 'Yey, Lets add it to list';
        $this->todos->addTodo($itemName);
        $this->webDriver->wait(10, 500)->until(function($driver) {
          $elements = $this->webDriver->findElements(WebDriverBy::cssSelector("[class='list-unstyled'] li:nth-child(6) span"));
          return count($elements) > 0;
        });
        .................................................
	  .................................................
        if ($condition_comp == true) {
            $coverage->stop();
            (new HtmlReport)->process($coverage, 'code-coverage-report
eport');
        }
	}

• As this is the final test case, we need to process the PHPUnit HTML report. Hence, a new PHPUnit coverage HTML report is generated using the process method of HtmlReport class. Coverage object and location where coverage reports would be stored (relative to the root folder) are passed to the process method.

public function testAddToList()
{
        global $condition_comp;
        if ($condition_comp == true) {
            global $coverage;
            $coverage->start('testAddToList');
        }
        .................................................
	  .................................................
        if ($condition_comp == true) {
            $coverage->stop();
            (new HtmlReport)->process($coverage, 'code-coverage-report
eport');
        }
}

e. tests\ FirefoxSearchTest.php

<?php 
 
require 'vendor/autoload.php';
require 'src/Search.php';
 
use PHPUnitFrameworkTestCase;
use FacebookWebDriverRemoteDesiredCapabilities;
use FacebookWebDriverRemoteRemoteWebDriver;
use FacebookWebDriverWebDriverBy;
 
use SebastianBergmannCodeCoverageCodeCoverage;
use SebastianBergmannCodeCoverageDriverDriver;
use SebastianBergmannCodeCoverageFilter;
use SebastianBergmannCodeCoverageReportHtmlFacade as HtmlReport;
 
$filter_t = new Filter;
$filter_t->includeFile('Path-to-locationSearch.php');
$driver_t = Driver::forLineCoverage($filter_t);
$coverage_t = new CodeCoverage($driver_t, $filter_t);
 
$condition_compl = true;
 
class FirefoxSearchTest extends TestCase
{
    protected $webDriver;
    protected $search;
 
    protected function setUp(): void
    {
        $this->webDriver = RemoteWebDriver::create('http://localhost:4444/wd/hub', DesiredCapabilities::firefox());
        $this->webDriver->get('https://www.google.com');
        $this->webDriver->manage()->window()->maximize();
        $this->search = new Search($this->webDriver);
        print("FCalled");
    }
    
    /*
     * @covers Search::ClickSearchResult
     */
    public function testSearchResult()
    {
        global $condition_compl;
        if ($condition_compl == true) {
            global $coverage_t;
            $coverage_t->start('testSearchResult');
        }
        $this->search->SearchonGoogle("LambdaTest");
        sleep(2);
        $this->search->ClickSearchResult();
        sleep(2);
        $this->assertEquals('Most Powerful Cross Browser Testing Tool Online | LambdaTest', $this->webDriver->getTitle());
        if ($condition_compl == true) {
            $coverage_t->stop();
            (new HtmlReport)->process($coverage_t, 'code-coverage-report
eport');
        }
    }
    
    public function tearDown(): void
    {
        $this->webDriver->quit();
    }
}

Here is the code walkthrough of the test implementation used for running Test Scenario-2.

• Along with including autoload.php from the vendor folder, we also include the PHP file (i.e., Search.php) whose methods would be used in the test code.

require 'vendor/autoload.php';
require 'src/Search.php';

• An instance of the Firefox browser is invoked in the setUp method, and the URL is set to https://www.google.com.

protected function setUp(): void
{
        $this->webDriver = RemoteWebDriver::create('http://localhost:4444/wd/hub', DesiredCapabilities::firefox());
        $this->webDriver->get('https://www.google.com');
        .................................................
	  .................................................
}

• A new object of the Search class is created and a webdriver object is used as the input argument.

$this->search = new Search($this->webDriver);

• The ClickSearchResult() method, which was implemented in the Search class, is tested here.

  The test code contains only one test case, i.e., testSearchResult(). Hence, start and stop methods of code coverage object and the test code report’s processing is done in this method.

public function testSearchResult()
{
        global $condition_compl;
        if ($condition_compl == true) {
            global $coverage_t;
            $coverage_t->start('testSearchResult');
        }
        $this->search->SearchonGoogle("LambdaTest");
        sleep(2);
        $this->search->ClickSearchResult();
        sleep(2);
        $this->assertEquals('Most Powerful Cross Browser Testing Tool Online | LambdaTest', $this->webDriver->getTitle());
        if ($condition_compl == true) {
            $coverage_t->stop();
            (new HtmlReport)->process($coverage_t, 'code-coverage-report
eport');
        }
    }

• The quit method of RemoteWebDriver is invoked for closing the instance of the web browser.

public function tearDown(): void
{
	$this->webDriver->quit();
}

f. phpunit.xml.dist

As we have to invoke multiple test cases, we compose a test suite using XML configuration.

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" bootstrap="vendor/autoload.php" backupGlobals="false" backupStaticAttributes="false" colors="true" convertErrorsToExceptions="true" convertNoticesToExceptions="true" convertWarningsToExceptions="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
  <coverage>
    <include>
      <directory suffix=".php">src</directory>
    </include>
  </coverage> 
  <testsuites>
    <testsuite name="chrome">
      <file>src/Todos.php</file>
      <directory>tests/chrome</directory>
    </testsuite>
    <testsuite name="firefox">
      <file>src/Search.php</file>
      <directory>tests/firefox</directory>
    </testsuite>
  </testsuites>
  <php>
    <env name="APP_ENV" value="testing"/>
  </php>
</phpunit>

Between the <directory> tags, we include the location of the directory that contains the source implementation. In our case, it is src.

<coverage>
    <include>
      <directory suffix=".php">src</directory>
    </include>
</coverage>

The respective tests are added between the <testsuite> tags, and those are further enclosed between the <testsuites> tags. As we have two test cases, the implementation is located in different folders (i.e., tests/chrome/ChromeTodoTest.php and tests/firefox/FirefoxSearchTest.php), both would be stored under different <testsuite> tags. The details under <directory> tag indicate the source files’ location (i.e., src/Todos.php, src/ Search.php) so that coverage is calculated only against those files. If this is not done, the coverage is calculated against all the source files, and the coverage percentage would be incorrect.

<testsuites>
.................................................
.................................................
<testsuite name="chrome">
      <file>src/Todos.php</file>
      <directory>tests/chrome</directory>
</testsuite>
.................................................
.................................................
<testsuites>

Execution

For executing the test cases, invoke the following command on the terminal:

vendorinphpunit

We have not passed the directory details where the PHPUnit coverage HTML reports would be stored, as the directory details were already implemented using phpunit/php-code-coverage package methods.

Here is the terminal screenshot, which indicates that the tests have been successfully executed.

The PHPUnit framework invokes a new browser instance for each test case. Since tests\ChromeTodoTest.php comprises three test cases i.e. testClickli1(), testClickli2(), and testAddToList(); hence a fresh Chrome browser instance is invoked for every test case. Hence, we have the log under setUp (i.e., Called) is printed thrice on the terminal

The PHPUnit coverage HTML reports are available in the newly created directory – code-coverage-report.

Two reports named Search.php.html and Todos.php.html are created in the code coverage directory.

As seen in the PHPUnit HTML report contents, the test cases were instrumental in testing all the individual source files’ methods.

Contents of Search.php.html

Contents of Todods.php.html

We have obtained 100 percent code coverage, and the same is reflected in the test reports. As seen at the bottom of the reports, php-code-coverage used PCOV for performing code coverage.

Since we have enabled the PCOV extension in php.ini, hence it is used by php-code-coverage.

It is important to note that PCOV and Xdebug cannot be used simultaneously. Hence, one extension should be disabled in php.ini when the other one is used. For using php-code-coverage with Xdebug, we disable the PCOV extension and keep the entry titled zend_extension enabled in the file.

Here is the report snapshot after php-unit-coverage uses Xdebug. As indicated in the report footer, Xdebug 2.9.6 was used for code coverage report generation.

Our recommendation is to use phpunit/php-code-coverage with PCOV instead of Xdebug extension.

PHPUnit code coverage report on Cloud-based Selenium Grid

When using PHPUnit on a local Selenium Grid, the Selenium Grid Server has to be started up and the browser binaries have to be made available on that machine.

Testing and reporting on a local Selenium Grid is not scalable, as it becomes a daunting task to perform testing on different browsers and old browser versions. The respective browsers and their corresponding browser binaries have to be downloaded to that system.

Instead, using PHPUnit on a cloud-based Selenium Grid like TestMu AI lets you perform testing and reporting on close to 2,000+ real browsers & operating systems online. Porting the existing code that generates PHPUnit code coverage report from a local Selenium to a cloud-based Selenium Grid requires minimal changes.

After creating an account on TestMu AI, keep a note of the user-name & access-key available on the profile page since the combination would be used for accessing the resources on the Grid on TestMu AI. For the test scenarios 1 & 2, generate the browser capabilities using TestMu AI browser capabilities generator.

After generation of browser capabilities, we port the existing implementation that demonstrates reporting on local Selenium Grid to TestMu AI’s cloud-based Grid (i.e., only infrastructure-related changes in tests are made).

For reporting, we used php-code-coverage hence, the global variable $condition_compl is set to True.

<?php 
 
require 'vendor/autoload.php';
require 'src/Search.php';
 
...............................................
 
$GLOBALS['LT_USERNAME'] = "user-name";
# accessKey:  AccessKey can be generated from automation dashboard or profile section
$GLOBALS['LT_APPKEY'] = "access-key";
...............................................
...............................................
 
$driver_t = Driver::forLineCoverage($filter_t);
$coverage_t = new CodeCoverage($driver_t, $filter_t);
 
$condition_compl = true;
 
class FirefoxSearchTest extends TestCase
{
    protected $webDriver;
    protected $search;
 
    protected function setUp(): void
    {
        $capabilities = array(
            "build" => "[PHP-Reporting] Reporting with Firefox on macOS Mojave",
            "name" => "[PHP-Reporting] Reporting with Firefox on macOS Mojave",
            "platform" => "Windows 10",
            "browserName" => "Firefox",
            "version" => "78.0"
        );
        $url = "https://". $GLOBALS['LT_USERNAME'] .":" . $GLOBALS['LT_APPKEY'] ."@hub.lambdatest.com/wd/hub";
        $this->webDriver = RemoteWebDriver::create($url, $capabilities);
        ...............................................
	  ...............................................
        $this->search = new Search($this->webDriver);
        print("FCalled");
    }
    
    ...............................................
    ...............................................
 

As seen in the code snippet, capabilities that have been generated using the TestMu AI capabilities generator are used for testing. The combination of user-name and access-key, which are stored in global variables, is used for accessing the TestMu AI Grid [@hub.lambdatest.com/wd/hub]

We have marked the code changes for the ToDo test conducted on Chrome below.

Run the following command for executing the tests:

vendor\bin\phpunit

As seen in the execution screenshot obtained by accessing the Automation tab on TestMu AI, it is clear that four tests (in total) were executed on the Grid.

If you are a PHP expert, you can acquire a benchmark industry certification specializing in core PHP programming skills and expand your opportunities to advance your career in PHP automation testing.

It’s a Wrap

PHPUnit code coverage reports come extremely handy as they give detailed information about code coverage. This helps in optimizing the test code in a manner that the code coverage is optimum. Xdebug and PCOV are the two widely used extensions for code coverage analysis.

For creating a PHPUnit coverage report in HTML, the php-code-coverage module that is spun out from PHPUnit and extends Xdebug and PCOV should be used. Using PCOV and Xdebug for code coverage does not involve implementation changes. It is recommended to use php-code-coverage as there is better control over the test report generation.

For attaining better code coverage while using cross browser testing, it is recommended to shift the testing process to a cloud-based Selenium Grid. When moving to the cloud-based Grid, no changes are involved in the reporting mechanism, and minimal changes are involved in the test code.

2M+ Devs and QAs rely on TestMu AI

Deliver immersive digital experiences with Next-Generation Mobile Apps and Cross Browser Testing Cloud

Sign up with googleSign up with Email