Irrespective of the application you’re dealing with, testing is an important and often overlooked aspect that you should give the attention it deserves. Today, we’re going to discuss it in the context of the Laravel web framework.
In fact, Laravel already supports the PHPUnit testing framework in the core itself. PHPUnit is one of the most popular and widely accepted testing frameworks across the PHP community. It allows you to create both kinds of tests—unit and functional.
We’ll start with a basic introduction to unit and functional testing. As we move on, we’ll explore how to create unit and functional tests in Laravel. I assume that you’re familiar with basics of the PHPUnit framework as we will explore it in the context of Laravel in this article.
Unit and Functional Tests
If you’re already familiar with the PHPUnit framework, you should know that you can divide tests into two flavors—unit tests and functional tests.
In unit tests, you test the correctness of a given function or a method. More importantly, you test a single piece of your code’s logic at a given time.
In your development, if you find that the method you’ve implemented contains more than one logical unit, you’re better off splitting that into multiple methods so that each method holds a single logical and testable piece of code.
Let’s have a quick look at an example that’s an ideal case for unit testing.
public function getNameAttribute($value) { return ucfirst($value); }
As you can see, the method does one and only one thing. It uses the ucfirst
function to convert a title into a title that starts with uppercase.
Whereas 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 a user performs in an application in order to run a specific use case.
For example, you could implement a functional test case for some login functionality that may involve the following steps.
- Create the GET request to access the login page.
- Check if we are on the login page.
- Generate the POST request to post data to the login page.
- Check if the session was created successfully.
So that’s how you’re supposed to create the functional test case. From the next section onward, we’ll create examples that demonstrate how to create unit and functional test cases in Laravel.
Setting Up the Prerequisites
Before we go ahead and create actual tests, we need to set up a couple of things that’ll be used in our tests.
We will create the Post model and related migration to start with. Go ahead and run the following artisan command to create the Post
model.
$php artisan make:model Post --migration
The above command should create the Post
model class and an associated database migration as well.
The Post
model class should look like:
And the database migration file should be created at
database/migrations/YYYY_MM_DD_HHMMSS_create_posts_table.php
.We also want to store the title of the post. Let's revise the code of the
Post
database migration file to look like the following.increments('id'); $table->string('name'); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('posts'); } }As you can see, we've added the
$table->string('name')
column to store the title of the post. Next, you just need to run the migrate command to actually create that table in the database.$php artisan migrateAlso, let's replace the
Post
model with the following contents.We've just added the
accessor
method, which modifies the title of the post, and that's exactly what we'll test in our unit test case. That's it as far as thePost
model is concerned.Next, we'll create a controller file at
app/Http/Controllers/AccessorController.php
. It'll be useful to us when we create the functional test case at a later stage.get("id", 0); // load the requested post $post = Post::find($post_id); // check the name property return $post->name; } }In the
index
method, we retrieve the post id from the request parameters and try to load the post model object.Let's add an associated route as well in the
routes/web.php
file.Route::get('accessor/index', 'AccessorController@index');And with that in place, you can run the http://your-laravel-site.com/accessor/index URL to see if it works as expected.
Unit Testing
In the previous 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.
As always, Laravel provides an artisan command that allows you to create the base template class of the unit test case.
Run the following command to create the
AccessorTest
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 thetests/Unit
directory.$php artisan make:test AccessorTest --unitAnd that should create the following class at
tests/Unit/AccessorTest.php
.assertTrue(true); } }Let's replace it with some meaningful code.
name); // load post using Eloquent $model_post = Post::find(1); $model_post_title = $model_post->name; $this->assertEquals($db_post_title, $model_post_title); } }As you can see, the code is exactly the same as it would have been in core PHP. We've just imported Laravel-specific dependencies that allow us to use the required APIs. In the
testAccessorTest
method, we're supposed to test the correctness of thegetNameAttribute
method of thePost
model.To do that, we've fetched an example 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 thegetNameAttribute
method as well to prepare the post title. Finally, we use theassertEquals
method to compare both variables as usual.So that's how to prepare unit test cases in Laravel.
Functional Testing
In this section, we'll create the functional test case that tests the functionality of the controller that we created earlier.
Run the following command to create the
AccessorTest
functional test case class. As we're not using the--unit
keyword, it'll be treated as a functional test case and placed under thetests/Feature
directory.$php artisan make:test AccessorTestIt'll create the following class at
tests/Feature/AccessorTest.php
.assertTrue(true); } }Let's replace it with the following code.
name); $response = $this->get('/accessor/index?id=1'); $response->assertStatus(200); $response->assertSeeText($db_post_title); } }Again, the code should look familiar to those who have prior experience in functional testing.
Firstly, we're fetching an example post from the database and preparing the expected output in the
$db_post_title
variable. Following that, we try to simulate the/accessor/index?id=1
GET request and grab the response of that request in the$response
variable.Next, we've tried to match the response code in the
$response
variable with the expected response code. In our case, it should be 200 as we should 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 theassertSeeText
method.And that's an example of the functional test case. Now, we have everything we could run our tests against. Let's go ahead and run the following command in the root of your application to run all tests.
$phpunitThat should run all tests in your application. You should see a standard PHPUnit output that displays the status of tests and assertions in your application.
And with that, we're at the end of this article.
Conclusion
Today, we explored the details of testing in Laravel, which already supports PHPUnit in its core. The article started with a basic introduction to unit and functional testing, and as we moved on we explored the specifics of testing in the context of Laravel.
In the process, we created a handful of examples that demonstrated how you could create unit and functional test cases using the artisan command.
If you're just getting started with Laravel or looking to expand your knowledge, site, or application with extensions, we have a variety of things you can study in Envato Market.
Don't hesitate to express your thoughts using the feed below!
Powered by WPeMatico