PHPUnit separation of tests [closed] - php

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
I'm using Symfony 2.8 (latest) for an web-application where every part of the application which could be used alone / reused is an own bundle. For example there is a NewsBundle, GalleryBundle, ContactBundle, AdminBundle (this is a special case - it's only a wrapper-bundle for EasyAdminBundle collecting the traits provided by the specific bundles), UserBundle (Child bundle of FOSUserBundle storing user-entity and templates)
My question is basically, whats the best structure for unit-tests?
Let me explain it a little bit more: In my UserBundle I want to make tests for my implementation of FOSUserBundle. I have a method testing the login-page (via HTTP status-code), login-failure (via error-message), login-successful (via specific code-elements), remember-me (via Cookie), logout (via page-content)
<?php
namespace myNamespace\Admin\UserBundle\Tests;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
/**
* Class FOSUserBundleIntegrationTest.
*/
class FOSUserBundleIntegrationTest extends WebTestCase
{
/**
* Tests the login, login "remember-me" and logout-functionality.
*/
public function testLoginLogout()
{
// Get client && enable to follow redirects
$client = self::createClient();
$client->followRedirects();
// Request login-page
$crawler = $client->request('GET', '/admin/login');
// Check http status-code, form && input-items
$this->assertTrue($client->getResponse()->isSuccessful());
$this->assertEquals(1, $crawler->filter('form[action="/admin/login_check"]')->count());
$this->assertEquals(1, $crawler->filter('input[name="_username"]')->count());
$this->assertEquals(1, $crawler->filter('input[name="_password"]')->count());
$this->assertEquals(1, $crawler->filter('input[type="submit"]')->count());
// Clone client and crawler to have the old one as template
$clientLogin = clone $client;
$crawlerLogin = clone $crawler;
// Get form
$formLogin = $crawlerLogin->selectButton('_submit')->form();
// Set wrong user-data
$formLogin['_username'] = 'test';
$formLogin['_password'] = '123';
// Submit form
$crawlerLoginFailure = $clientLogin->submit($formLogin);
// Check for error-div
$this->assertEquals(1, $crawlerLoginFailure->filter('div[class="alert alert-error"]')->count());
// Set correct user-data
$formLogin['_username'] = 'mmustermann';
$formLogin['_password'] = 'test';
// Submit form
$crawlerLoginSuccess = $client->submit($formLogin);
// Check for specific
$this->assertTrue(strpos($crawlerLoginSuccess->filter('body')->attr('class'), 'easyadmin') !== false ? true : false);
$this->assertEquals(1, $crawlerLoginSuccess->filter('li[class="user user-menu"]:contains("Max Mustermann")')->count());
$this->assertEquals(1, $crawlerLoginSuccess->filter('aside[class="main-sidebar"]')->count());
$this->assertEquals(1, $crawlerLoginSuccess->filter('div[class="content-wrapper"]')->count());
// Clone client from template
$clientRememberMe = clone $client;
$crawlerRememberMe = clone $crawler;
// Get form
$formRememberMe = $crawlerRememberMe->selectButton('_submit')->form();
// Set wrong user-data
$formRememberMe['_username'] = 'mmustermann';
$formRememberMe['_password'] = 'test';
$formRememberMe['_remember_me'] = 'on';
// Submit form
$crawlerRememberMe = $clientRememberMe->submit($formRememberMe);
// Check for cookie
$this->assertTrue($clientRememberMe->getCookieJar()->get('REMEMBERME') != null ? true : false);
// Loop all links on page
foreach ($crawlerRememberMe->filter('a')->links() as $link) {
// Check for logout in uri
if (strrpos($link->getUri(), 'logout') !== false) {
// Set logout-link
$logoutLink = $link;
// Leave loop
break;
}
}
// Reuse client to test logout-link
$logoutCrawler = $clientRememberMe->click($logoutLink);
// Get new client && crawl default-page
$defaultPageClient = self::createClient();
$defaultPageCrawler = $defaultPageClient->request('GET', '/');
// Check http status-code, compare body-content
$this->assertTrue($defaultPageClient->getResponse()->isSuccessful());
$this->assertTrue($logoutCrawler->filter('body')->text() == $defaultPageCrawler->filter('body')->text());
}
}
All this tests will be done in one method because if I would do it in different methods I would have an high amount (5x4 lines = 20 lines copy & paste) of duplicated code. Does this follow the best practice? What is the best practice for separating unit-tests? (or other worded: How would you do it?)
Part two of the question: Is there a possibility to provide helper-functions for test-classes or something working similar to it? I mean methods as example which provide an logged in client. This would be needed for admin function-tests.

Answer 1

Now that your question is more specific, I will provide an answer with some explanation. What you are doing for your first test may work but is not the way you should be testing. It's not so much best practice as it is you circumventing the idea of a unit test, checking assumptions against a single unit of work. Your test has several 'units' of work being tested, and they should all be in separate tests.
Here is a condensed example of more appropriate tests for your first two cases:
public function testLoginForm()
{
$client = self::createClient();
$crawler = $client->request('GET', '/admin/login');
$this->assertTrue($client->getResponse()->isSuccessful());
$this->assertEquals(1, $crawler->filter('form[action="/admin/login_check"]')->count());
$this->assertEquals(1, $crawler->filter('input[name="_username"]')->count());
$this->assertEquals(1, $crawler->filter('input[name="_password"]')->count());
$this->assertEquals(1, $crawler->filter('input[type="submit"]')->count());
}
public function testLoginFailure()
{
$client = self::createClient();
$crawler = $client->request('GET', '/admin/login');
$form = $crawler->selectButton('_submit')->form();
$form['_username'] = 'test';
$form['_password'] = '123';
$crawler = $client->submit($form);
$this->assertEquals(1, $crawler->filter('div[class="alert alert-error"]')->count());
}
A few things here.
You are worried about code duplication and extra lines of code, but I just created two separate tests that didn't increase the line count at all. I was able to remove the followRedirects() call since it didn't apply to those tests, and I eliminated the two lines of cloning by simply recreating the client and crawler as normal, which is less confusing.
With your code there is only one unit test, but if that test fails it could be for any number of different reasons - login failure, login success, etc. So if that test fails you have to sift through the error messages and find out which part of your system failed. By separating out the tests, when a test fails you know what went wrong simply by the name of the test.
You can eliminate some of your redundant code comments by separating your tests: // Set wrong user-data is no longer needed because the test itself is called testLoginFailure().
Not only is it unit-testing best practice, but there is another caveat when it comes to using WebTestCase, in that you want all of your tests isolated. I've tried to make a static $client variable that the entire class can use, thinking that I'll save memory/time if I only instantiate one instance, but this causes unpredictable behavior when you start running multiple tests. You want your tests to occur in isolation.
You could also use the setUp() and tearDown() functions and have a $this->client and $this->crawler instantiated before each request if you were really trying to eliminate redundant code:
use Symfony\Bundle\FrameworkBundle\Client;
use Symfony\Component\DomCrawler\Crawler;
/*
* #var Client
*/
private $client;
/*
* #var Crawler
*/
private $crawler;
/*
* {#inheritDoc}
*/
protected function setUp()
{
$this->client = self::createClient();
$this->crawler = $this->client->request('GET', '/admin/login');
}
/*
* {#inheritDoc}
*/
protected function tearDown()
{
unset($this->client);
unset($this->crawler);
}
...but then you're creating class-level code to declare those variables, instantiate them, and tear them down. You also ended up adding a lot of additional code, which is what you were trying to avoid in the first place. Additionally, your entire test class is now rigid and inflexible, because you can never request a page other than the login page. Plus, PHPUnit itself states:
The garbage collection of test case objects is not predictable.
The above statement is in regard to if you don't remember to manually clean up your tests. So you may encounter unexpected behavior for those reasons in addition to the other ones I described above.
As for your second question, sure, provide helper-functions or extend the existing *TestCase classes. The Symfony documentation even provides an example for this with a private function that logs in a user. You could put that in an individual test class like their documentation, or you could make your own MyBaseTestCase class that has that function in it.
TL;DR Don't try to be clever with your tests/test cases, separate your tests, and create helper functions or base test case classes to extend from if you reuse a lot of the same setups.