Web Application

How developers test their own code? – Unit Testing

When we develop any application, testing is a major part of the development. After development, functionality testing is crucial as it can easily help identify any flaws in the code. After you are sure your code works well as per requirements, you can integrate it with the system and perform integration tests to make sure it works with the other units too.

Developers are often faced with a challenge where the methods may be easy, but the application doesn’t work because of a small bug. Now imagine, that you have a system with hundreds of methods, and suddenly a bug appears, and you need to track it and resolve it. This might take a very long time. It is in situations like this that Code testing and Unit testing in a particular section can help prevent this type of problem.

So today we are going to discuss it in detail with the PHP development framework Laravel. In fact, the Laravel framework is also a PHP Unit testing framework itself. PHP Unit is one of the most popular and widely useful testing frameworks. PHP Unit allows us to create both kinds of testing-Unit testing and Functional Testing.

We will learn the introduction of Unit and functional testing. Now, we’ll learn how to develop unit testing and functional testing in Laravel.

Unit and Functional Tests

If you already know about PHP Unit testing, we can divide testing into two different sections- Unit Testing and Functional Testing.

1. Unit Testing

  • It is testing where you can test individual units/components of a developed functionality. The main aim is to work on each module as per the requirement of the client.
  • It is the most important part of testing. Using fill up the input forms and generate a single output of testing. More importantly, you test a single piece of your code’s logic at a given time.

 

2. Functional Test

  • It is the process of testing the functionality of a quality assurance process and a black-box type testing that bases the specifications of the software component test as per its use cases.
  • Functions are tested by filling up the form inputs and verifying the output, and the internal program structure is mostly considered.


Let’s have a quick look in the below example that’s an ideal case for unit testing.

public function getPostTitle($value)

{

return ucfirst($value);

}

  • As you can see, the method does one and only one thing. It uses the ucfirst function to get the title, title first character convert into uppercase.
  • The unit test is used to test the correctness of a single logical unit of code. The functional test, on the other hand, allows you to test the correctness of a specific use case. More specifically, it allows you to simulate actions that a user performs in an application in order to run a specific use case.
  • Let’s create an example that demonstrates how to create unit and functional testing in Laravel.


Setting up the obligatory

Before we go ahead and create an actual test, we need to set up a couple of things that will be used in testing. We will create Posts modal and related migration.

Go ahead and run below command in the terminal.

$php artisan make:model Posts –migration
  • The above command should create the Posts model class and an associated database migration as well.
  • The Posts model should look like this:
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Posts extends Model

{

//

}

  • And the database migration file should be created atdatabase/migrations/YYYY_MM_DD_HHMMSS_create_posts_table.php.
  • The migrations should look like this:
<?php

 

use Illuminate\Support\Facades\Schema;

use Illuminate\Database\Schema\Blueprint;

use Illuminate\Database\Migrations\Migration;

 

class CreatePostsTable extends Migration

{

/**

* Run the migrations.

*

* @return void

*/

public function up()

{

Schema::create(‘posts’, function (Blueprint $table) {

$table->increments(‘id’);

$table->string(‘post_name’);

$table->timestamps();

});

}

/**

* Reverse the migrations.

* @return void

*/

public function down()

{

Schema::dropIfExists(‘posts’);

}

}

  • As above exmaple, i have added one line $table->string(‘post_name’);. That line store post title name. Now just run to migration command to create post table.
$php artisan migrate
  • Now we replace the below code in Posts model.
<?php

 

namespace App;

 

use Illuminate\Database\Eloquent\Model;

 

class Posts extends Model

{

/*

get post title name convert, first character in Uppercase

*/

public function getPostTitle($value)

{

return ucfirst($value);

}

}

  • We have just added the accessor method, which modifies the title of the post, and that’s exactly what we will test in our unit test case. That’s it, as far as the Posts model is concerned.
  • Next, we will create the Controller file in ‘app/Http/Controllers/PostController.php‘. It’ll be useful to us when we create the functional test case at a later stage.
<?php

// app/Http/Controllers/PostController .php

 

namespace App\Http\Controllers;

 

use App\Posts;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;

class PostController extends Controller

{

public function index(Request $request)

{

// get the post-id from request params

$post_id = $request->get(“id”, 1);

// load the requested post

$post = Posts::find($post_id);

// check the name property

return ($post)?$post->name:”No Data”;

}

}

  • In the above controller ‘index‘, retrieve the post id from the request parameters and try to load the post model object.
  • Let’s add the route as well in ‘route/web.php‘ file.
Route::get(‘posts/index’, ‘PostController@index’);
  • And with that in place, you can run the http://your-laravel-site.com/posts/index URL to see if it works as expected.


Unit Testing

In the precedent section, we did the initial setup that’s going to be useful to us in this and upcoming sections. In this section, we are going to create an example that demonstrates the concepts of unit testing in Laravel.

  • Laravel provides an artisan command that always to create the base template class of unit case.
  • Run above command to create the ‘PostsTest’ unit test case class. It’s important to note that we’re passing the –unit keyword that creates the unit test case, and it’ll be placed under the tests/unit directory.
$php artisan make:test PostsTest –unit
  • And that should create the following class at ‘tests/Unit/PostsTest.php
<?php

 

namespace Tests\Unit;

 

use Tests\TestCase;

use Illuminate\Foundation\Testing\WithFaker;

use Illuminate\Foundation\Testing\RefreshDatabase;

 

class PostsTest extends TestCase

{

/**

* A basic test example.

*

* @return void

*/

public function testExample()

{

$this->assertTrue(true);

}

}

  • Let’s replace it with some meaningful code.
<?php

 

namespace Tests\Unit;

 

use Tests\TestCase;

use Illuminate\Foundation\Testing\WithFaker;

use Illuminate\Foundation\Testing\RefreshDatabase;

use DB;

use App\Posts;

 

class PostsTest extends TestCase

{

 

public function testAccessorTest()

{

// load post manually first

$db_post = DB::select(‘select * from posts where id = 1’);

$db_post_title = ucfirst($db_post[0]->name);

 

// load post using Eloquent

$model_post = Posts::find(1);

$model_post_title = $model_post->name;

 

$this->assertEquals($db_post_title, $model_post_title);

}

}

  • In the ‘testAccessorTest‘ method, we’re supposed to test the correctness of the ‘getPostTitle‘ method of the Posts model.
  • For this, we have fetched a post from the database and prepared the expected output in the ‘$db_post_title‘ variable. Next, we load the same post using the Eloquent model that executes the ‘getPostTitle‘ method as well to prepare the post title. Finally, we use the assertEquals method to compare both variables as usual.
  • So that’s the process of how to prepare unit test cases in the Laravel framework.


Functional Testing

  • In this section, we will create the functional test case that tests the functionality of the controller that we have created.
  • Now we run the below command and create the ‘PostsTest‘ functional test case class. As we not using the unit keyword, it will work as a functional test case and placed under the ‘tests/Feature‘ directory.
$php artisan make:test PostsTest
  • It will create the following class in ‘tests/Feature/PostsTest.php‘.
<?php

namespace Tests\Feature;

 

use Tests\TestCase;

use Illuminate\Foundation\Testing\WithFaker;

use Illuminate\Foundation\Testing\RefreshDatabase;

 

class PostsTest extends TestCase

{

/**

* A basic test example.

*

* @return void

*/

public function testExample()

{

$this->assertTrue(true);

}

}

  • Let’s replace it with some meaningful code.
<?php

 

namespace Tests\Feature;

 

use Tests\TestCase;

use Illuminate\Foundation\Testing\WithoutMiddleware;

use Illuminate\Foundation\Testing\DatabaseMigrations;

use Illuminate\Foundation\Testing\DatabaseTransactions;

use DB;

 

class PostsTest extends TestCase

{

/**

* A basic test example.

*

* @return void

*/

public function testBasicTest()

{

// load post manually first

$db_post = DB::select(‘select * from posts where id = 1’);

$db_post_title = ucfirst($db_post[0]->name);

 

$response = $this->get(‘/posts/index?id=1’);

 

$response->assertStatus(200);

$response->assertSeeText($db_post_title);

}

}

  • Firstly, we are fetching the title from the database and preparing the expected output in the ‘$db_post_title‘ variable. Following that, we try to simulate the ‘/posts/index?id=1‘ GET request and grab the response of that request in the $response variable.
  • Next, we check the response code in the $response variable with the response code. In this case, it should be 200 so that we can get a valid response for our GET request. Further, the response should contain a title that starts with uppercase, and that’s exactly what we’re trying to match using the assertSeeText method.
  • Now we have done everything we could run our tests against. Let’s now run the below command in the root of your application to run all tests.
$phpunit
  • The above command will run all tests in your application. You should see standard PHPUnit output that displays status of tests and assertions in your application.


Test Result

  • If you get the 200 valid response in GET Request, below output will be the command line.
PHPUnit 6.5.14 by Sebastian Bergmann and contributors.

 

..                                                                  2 / 2 (100%)

 

Time: 140 ms, Memory: 16.00MB

 

OK (2 tests, 3 assertions)

  • If the code fails during test cases, you will get the below output.

i.e. I have changed the in file at ‘tests/Unit/PostsTest.php‘. Just replace the code ‘$db_post = DB::select(‘select * from posts where id = 2′);’ in place of ‘$db_post = DB::select(‘select * from posts where id = 1′);’ and run command ‘phpunit‘. You will get test result as below.

PHPUnit 6.5.14 by Sebastian Bergmann and contributors.

 

.F                                                                  2 / 2 (100%)

 

Time: 115 ms, Memory: 16.00MB

 

There was 1 failure:

 

1) Tests\Unit\PostsTest::testAccessorTest

Failed asserting that two strings are equal.

— Expected

+++ Actual

@@ @@

-‘Post 2′

+’Post 1’

 

/var/www/html/your-laravel-site-folder/tests/Unit/PostsTest.php:24

/usr/share/php/PHPUnit/TextUI/Command.php:206

/usr/share/php/PHPUnit/TextUI/Command.php:162

 

FAILURES!

Tests: 2, Assertions: 3, Failures: 1.

So, this is all about unit testing, here we have share How developers test their own code and how it can be help you to better manage and control projects. If you have any confusion regarding this please contact our expert at https://www.oneclickitsolution.com/contact-us/.

Want to read more Blogs ?

Similar Post

Certified By

  •                            
    Clutch
    11 Reviews
  • Upwork
    97% job success
    Good Firms
    7 Reviews