ToggleOn – dit alla noder leder.

Skapa enhetstest i CodeIgniter

I detta inlägg ska vi undersöka hur man går till väga för att skapa enhetstest i CodeIgniter.

För den som inte är bekant med CodeIgniter är det ett webbramverk för PHP-programmerare. Vi har tidigare på bloggen skrivit om CodeIgniter här. Där står det hur du kommer igång med CodeIgniter.

Mer specifikt kommer vi i det här inlägget att:

• Förklara vad enhetstest är och varför de är viktiga
• Hur man kan skapa enkla enhetstest
• Mer avancerade tillval för att skapa enhetstest
• Hur man går till väga för att räkna antalet lyckade och misslyckade genomförda enhetstester.

Vi kommer utgå från att CodeIgniter 1.7.2 eller senare är installerat.

Vad är enhetstest?

Enhetstest (eng. unit test) är ett sätt att testa en enskild enhet, i form av en klass, funktion, eller något dylikt. Syftet med enhetstestet är att undersöka om en viss indata ger korrekt utdata. Fördelen med detta är att det försäkrar (så långt det går) programmeraren om att en enhet håller hög kvalitet.

Enhetstest i CodeIgniter

Enhetstest i CodeIgniter finns inbyggt i form av bibliotek.

Gå till system > libraries och öppna Unit_test.php. Ha denna fil öppen, eftersom vi kommer behöva den filen i sista steget.

Öppna en valfri controller. Här kommer vi använda controllern Site som exempel.

Det första vi behöver göra är att ladda in biblioteket för Unit_test. Detta gör vi med:

$this->load->library('unit_test');

När vi har laddat in detta bibliotek är vi redo att börja skriva enhetstester.

För att testa en enhet anropar vi funktionen run(). Som parametrar tar den emot:

• Vad som skall testas (t.ex. ett funktionsanrop eller uttryck).
• Förväntat resultat från det som testas.
• Namnet på eller en förklarande text till enhetstestet.

Detta illustreras bäst med ett exempel. Vi testar ett vanligt aritmetiskt uttryck. Därefter anropar vi run(), som returnerar en rapport i form av en HTML-tabell som vi kan skriva ut.

class Site extends Controller {
        function index() {
            $this->load->library('unit_test');
            $test = 1 + 1;
            $expected_result = 2;
            $test_description = "Add one and one";
            echo $this->unit->run($test, $expected_result, $test_description);

            $test2 = 2 + 2;
            $expected_result2 = 4;
            $test_description2 = "Add two and two";
            echo $this->unit->run($test2, $expected_result2, $test_description2);
        }
}

Resultatet visas i illustrationen nedanför:

Enklare enhetstest i CodeIgniter

Generera rapporter

Istället för att anropa run() och skriva ut dem kan vi exekvera alla enhetstest med run() och därefter anropa report() för att få ut en fullständig rapport. Koden ovanför skulle i sådana fall se ut så här:

            $this->load->library('unit_test');
            $test = 1 + 1;
            $expected_result = 2;
            $test_description = "Add one and one";
            $this->unit->run($test, $expected_result, $test_description);

            $test2 = 2 + 2;
            $expected_result2 = 4;
            $test_description2 = "Add two and two";
            $this->unit->run($test2, $expected_result2, $test_description2);

            echo $this->unit->report();

Istället för att skriva ut det run() returnerar så skriver vi helt enkelt ut det som returneras från report(), vilket är samtliga enhetstest. Resultatet av detta blir densamma som i föregående kodexempel.

Strict Mode

Enhetstester i CodeIgniter testar inte datatyper mot varandra. Följande test

            $this->unit->run(1, TRUE);

kommer passera, eftersom 1 och TRUE anses vara likvärdiga. Om värden så väl som datatyper skall testas måste strict mode aktiveras. Följande test

            $this->unit->use_strict(TRUE);
            $this->unit->run(1, TRUE);

kommer misslyckas, eftersom 1 och TRUE inte anses vara likvärdiga, då de har olika datatyper.

Antal lyckade och misslyckade enhetstest

[Denna del av inlägget är till för mer avancerade användare av CodeIgniter]

Det finns inget direkt sätt att hämta antal lyckade och misslyckade enhetstest i CodeIgniter.

Däremot går det att hämta rådata med funktionen result(). Detta returnerar en array där resultatet av alla enhetstester finns samlade. Mer specifikt finns nycklar med namnet ”result”. Dessa kan ha värdet ”failed” eller ”passed”. Om vi räknar dessa kan vi få ut hur många test som lyckades och hur många som misslyckades.

Då har vi två designval att utgå från:

1. Antingen går vi in i klassen Unit_test direkt och lägger in funktioner för att räkna antal lyckade och misslyckade test, eller så
2. Anropar vi metoden result() utanför klassen Unit_test och hanterar den array vi får tillbaka.

Nackdelen med första alternativet är att om vi uppgraderar från 1.7.2 till 1.7.3 av CodeIgniter så försvinner vår kod, om vi inte manuellt går in och lägger in den igen. Fördelen med första alternativet är att det känns mer intuitivt att använda. Det känns givet att en enhetstestklass har enkel funktionalitet för att hämta antal lyckade och misslyckade enhetstester.

Vi kan lösa detta på ett antal sätt. Vi kan t.ex. skapa en helperfunktion som laddar in Unit_test och anropar result(). Här kommer vi i istället utgå från ett annat alternativ: ärva från Unit_test och lägga in våra funktioner.

Börja med att gå till katalogen system/application/libraries. Skapa en ny fil och ge den namnet MY_Unit_test.php. Den ska till att börja med innehålla:

class MY_Unit_test extends CI_Unit_test {
    function MY_Unit_test() {
        parent::CI_Unit_test();
    }
}

Vi låter MY_Unit_test ärva från CI_Unit_test. Från konstruktorn för MY_Unit_test anropar vi konstruktorn till superklassen.

Vad vi vill göra är lägga in en funktion för att iterera genom resultatet, räkna antal förekomster av lyckade/misslyckade enhetstester, och returnera detta. Funktionen för detta ser ut så här:

    function _get_result($key_arg, $val_arg) {
        $count = 0;
        foreach($this->results as $index => $first_array) {
            foreach($first_array as $index2 => $second_array) {
                foreach($second_array as $key => $val) {
                    if ($key == $key_arg && $val == $val_arg) {
                        $count++;
                    }
                }
            }
        }
        return $count;
    }

Som inargument tar funktionen emot dels namnet på nyckeln, och dels namnet på värdet som vi ska testa mot.

Vi itererar genom $this->results där resultaten av alla enhetstester finns sparade. För att komma åt den viktiga arrayen måste vi iterera genom tre arrayer. I den innersta arrayen kollar vi om nyckeln och värdet stämmer. Om det gör det så räknar vi upp $count, som vi returnerar i slutet av funktionen.

Nu kan vi konstruera två funktioner, kallade passed_tests() och failed_tests() för att räkna antal lyckade/misslyckade test. Dessa funktioner ser ut så här:

    function passed_tests()
    {
        $passed = $this->_get_result("result", "passed");
        return $passed;
    }

    function failed_tests()
    {
        $failed = $this->_get_result("result", "failed");
        return $failed;
    }

Vad dessa funktioner gör bör vara självklart.

Den färdiga klassen ser ut så här:

class MY_Unit_test extends CI_Unit_test {
    function MY_Unit_test() {
        parent::CI_Unit_test();
    }

    function _get_result($key_arg, $val_arg) {
        $count = 0;
        foreach($this->results as $index => $first_array) {
            foreach($first_array as $index2 => $second_array) {
                foreach($second_array as $key => $val) {
                    if ($key == $key_arg && $val == $val_arg) {
                        $count++;
                    }
                }
            }
        }
        return $count;
    }

    function passed_tests()
    {
        $passed = $this->_get_result("result", "passed");
        return $passed;
    }

    function failed_tests()
    {
        $failed = $this->_get_result("result", "failed");
        return $failed;
    }
}

När vi sedan ska ladda in denna klass så skriver vi inte in $this->load->library(‘MY_Unit_test’). När vi skapar en utökad variant av en inbyggd klass och anropar load så kommer den egendefinierade klassen att laddas in. Detta förtydligas av exemplet nedanför, där vi använder vår egendefinierade klass:

            $this->load->library('unit_test');
            $test = 1 + 1;
            $expected_result = 2;
            $test_description = "Add one and one";
            $this->unit->run($test, $expected_result, $test_description);

            $test2 = 2 + 2;
            $expected_result2 = 4;
            $test_description2 = "Add two and two";
            $this->unit->run($test2, $expected_result2, $test_description2);

            echo "Passed: " . $this->unit->passed_tests();
            echo "Failed: " . $this->unit->failed_tests();
            echo $this->unit->report();

Koden för att göra detta direkt i klassen CI_Unit_Test är betydligt enklare. Läs kommentarerna nedanför för hur man går till väga för att göra det.

Till sist

Enhetstestning i CodeIgniter finns även dokumenterat här.

Detta var allt för detta inlägg. Om du har några frågor eller kommentarer kring enhetstestning i CodeIgniter, lämna då gärna en kommentar i kommentarsfältet eller skicka iväg ett mejl till ToggleOnBlog@gmail.com.