Tampilkan postingan dengan label php. Tampilkan semua postingan
Tampilkan postingan dengan label php. Tampilkan semua postingan

Selasa, 25 November 2008

Unit Testing di PHP (Bagian 2 Test Pertama)

Dalam tulisan sebelumnya, saya telah menjelaskan cara untuk melakukan instalasi PHPUnit. Berikutnya kita akan mulai membuat unit test menggunakan PHPUnit untuk aplikasi yang kita bangun. Sebelum kita mulai dengan test, mari kita buat dasar dari class yang akan kita test,

<?php

class Calculator {

public function add($a, $b) {
return 5;
}
}

Simpan ke dalam file dengan nama 'Calculator.php'. Kemudian, kita lanjutkan dengan membuat bentuk dasar dari test class kita. Sebuah test yang menggunakan PHPUnit memiliki bentuk dasar sebagai berikut:

<?php

require_once 'Calculator.php';
require_once 'PHPUnit/Framework.php';

class CalculatorTest extends PHPUnit_Framework_TestCase {

protected function setUp() {

}

protected function tearDown() {

}

public function testAdd() {

}
}

Tentunya kita mengikutsertakan file 'Calculator.php' karena kita akan membuat unit test untuk class tersebut. Anda dapat mengubah bagian tersebut sesuai dengan class yang ingin anda buatkan testnya.

Beberapa hal yang perlu dijelaskan adalah, test class harus melakukan extends terhadap PHPUnit_Framework_TestCase. Selain itu, masing-masing test method yang akan dijalankan, HARUS memiliki nama yang dimulai dengan kata 'test' dan bersifat public. Pada contoh di atas, method 'testAdd' merupakan salah satu method yang akan melakukan test. Tinggal dua method lagi yang belum dijelaskan, yaitu 'setUp' dan 'tearDown'.

Method dengan nama 'setUp' dan 'tearDown' merupakan method yang akan dijalankan setiap kali test method kita dijalankan. 'setUp' dijalankan sebelum masing-masing test method dan 'tearDown' dijalankan setelah masing-masing test method. Jadi, jika kita memiliki dua buah test method, misalnya 'testMethodSatu' dan 'testMethodDua', maka urutan dijalakannya method-method adalah:

  • setUp

  • testMethodSatu

  • tearDown

  • setUp

  • testMethodDua

  • tearDown


  • 'setUp' dapat digunakan untuk melakukan inisialisasi yang diperlukan sebelum sebuah test dijalankan, misalnya mempersiapkan data, membuat object yang dibutuhkan atau koneksi ke database. 'tearDown' dapat digunakan untuk melakukan pembersihan terhadap hasil proses test, misalnya menghapus file yang dibuat dalam test, menghapus data yang dimasukkan ke dalam database dan lain sebagainya. Dengan cara ini kita dapat memastikan method test selalu dijalankan dengan kondisi lingkungan yang tetap.

    Mari kita mulai membuat unit test kita. Saya hanya menampilkan potongan dari file 'CalculatorTest.php' di bawah ini:

    class CalculatorTest extends PHPUnit_Framework_TestCase {

    private $calculator;

    protected function setUp() {
    /* Kita membuat object calculator karena selalu dibutuhkan
    * dalam setiap test kita.
    */
    $this->calculator = new Calculator();
    }

    protected function tearDown() {

    }

    public function testAdd() {
    /* Pastikan hasil method add di calculator sesuai */
    $this->assertEquals(5, $this->calculator->add(2, 3));
    }
    }


    Di method setUp kita mempersiapkan sebuah object dari Calculator karena akan selalu dipergunakan dalam setiap test kita. Kemudian dalam method 'testAdd' kita melakukan pemanggilan terhadap $this->assertEquals . Method ini merupakan method yang disediakan oleh PHPUnit yang melakukan pengetasan apakah parameter pertama, sama dengan parameter kedua. Dalam contoh di atas, apakah 5 sama dengan hasil dari $this->calculator->add(2, 3). PHPUnit menyediakan beberapa fungsi 'assert' yang dapat digunakan untuk keperluan unit test yang berbeda.

    Saya mencoba untuk membuat test terlebih dahulu sebelum melakukan implementasi ke dalam class Calculator sendiri. Setelah test selesai dibuat, implementasi di dalam class dapat dibuat untuk melewati test yang ada. Pada saat ini jika kita menjalankan test, tentunya akan gagal. Coba lakukan perintah berikut:

    phpunit CalculatorTest

    Akan terjadi error karena kita belum memiliki method add di class Calculator. Mari kita lanjutkan dengan membuat method add. Kita membuat method hanya untuk melewati test yang telah dibuat.

    class Calculator {

    public function add($a, $b) {
    return 5;
    }
    }

    jika kita menjalankan phpunit kembali seperti perintah sebelumnya, test kita akan berhasil sekarang. Tetapi method add kita belum selesai. Tambahkan assertion lagi ke dalam unit test untuk memastikannya.

    public function testAdd() {
    /* Pastikan hasil method add di calculator sesuai */
    $this->assertEquals(5, $this->calculator->add(2, 3));

    /* Coba dengan nilai berbeda */
    $this->assertEquals(23, $this->calculator->add(15, 8));
    }

    Jika test dijalankan maka akan gagal kembali dengan pesan:

    'Failed asserting that <integer:5> matches expected value <integer:23>'
    /blog/CalculatorTest.php:20

    Hasil tersebut mengatakan bahwa, pada baris nomor 20 (di program saya nomor 20, lihat hasil dari test anda) terjadi perbedaan nilai, dimana yang diharapkan adalah 23 dan nilai hasil adalah 5. Hal tersebut terjadi karena method add kita selalu mengembalikan nilai 5. Mari kita ubah method tersebut:

    class Calculator {

    public function add($a, $b) {
    return $a + $b;
    }
    }

    Jalankan kembali test untuk melihat hasilnya.

    Coba tambahkan test dengan angka yang berbeda lagi, dan coba lihat hasilnya. Jika sudah berhasil, kita dapat membuat unit test dengan memasukkan nilai yang bukan angka sebagai parameter. Coba masukkan string, null ataupun array. Bagaimana hasilnya? Apakah terjadi error? Apakah hasilnya seperti yang kita inginkan?

    Ternyata membuat unit test menggunakan PHPUnit tidak sesulit yang saya bayangkan sebelumnya. Pada tulisan berikutnya saya akan menerangkan mengenai cara untuk melakukan unit test untuk memastikan bahwa sebuah error telah terjadi.

    Senin, 24 November 2008

    Unit Testing di PHP (Bagian 1 Instalasi)

    Sejalan dengan berkembangnya Object Oriented di PHP, penggunaan Testing Framework menjadi hal yang semakin banyak dibicarakan. Selain itu, PHP juga telah berkembang dari sekedar menambahkan efek dinamis di sebuah website kecil, menjadi bahasa pemrogramman aplikasi besar yang perlu memperhatikan ketepatan jalannya sebuah logika aplikasi. Dengan melakukan test yang menyeluruh, kita dapat memastikan ketepatan dari aplikasi yang kita bangun, seperti yang dijelaskan pada blog mengenai keuntungan melakukan test. Melihat hal tersebut, kita sebagai pembangun aplikasi di PHP harus sesegera mungkin mempelajari Testing Framework yang dapat membantu dalam pembangunan aplikasi.

    Salah satu testing framework yang sering digunakan untuk melakukan Unit Testing di PHP adalah PHPunit. PHPunit merupakan bagian dari xUnit Testing Framework yang memudahkan penulisan testing dan menganalisa hasil dari test yang dilakukan. Instalasi PHPunit sendiri sangat mudah karena menggunakan bantuan PEAR installer dalam menjalankannya. Berikut cara instalasi PHPunit menggunakan PEAR installer.

    Pertama-tama kita perlu mendaftarkan PEAR channel yang digunakan untuk mendistribusi PHPunit. Hal ini dilakukan dengan memberikan perintah:

    pear channel-discover pear.phpunit.de

    Setelah hal tersebut dijalankan, instalasi dapat dilakukan dengan:

    pear install phpunit/PHPUnit


    Setelah instalasi selesi, kita dapat menemukan file source PHPUnit di tempat kita meletakkan PEAR package. Hal ini tergantung distribusi PHP anda. Ada baiknya kita menambahkan directory tempat phpunit ke dalam PATH sehingga kita bisa memanggil program tersebut dari mana saja. Untuk memastikan instalasi berhasil, coba jalankan perintah berikut:

    phpunit --version

    akan keluar versi dari phpunit yang terinstall di tempat anda. Sekarang, kita tinggal membuat Unit Test yang sesuai dengan aplikasi yang kita bangun dan memanggil phpunit untuk menjalankannya. Bagaimana cara membuat unit test pertama anda, dengan menggunakan PHPUnit, akan dijelaskan pada tulisan berikutnya.

    Jumat, 21 November 2008

    Static Keyword di PHP5

    Dengan mendefinisikan sebuah property ataupun method menggunakan kata-kata static, kita dapat mengakses property atau method tersebut tanpa melakukan inisiasi terhadap class yang mendefinisikannya. Dari dokumentasi mengenai static keyword di PHP5, ada beberapa hal yang perlu diperhatikan:
    1. Deklarasi kata static harus setelah deklarasi dari visibility, contoh

    public static $data;

    BUKAN

    static public $data;

    Jika tidak ada deklarasi visibility, maka property atau method tersebut akan dianggap public.

    2. Karena static method dapat dipanggil tanpa melakukan instansiasi dari object, maka penggunaan kata '$this' tidak berlaku untuk method yang menggunakan deklarasi static.

    3. Static property tidak dapat diakses menggunaan operator tanda panah (->), tetapi static method dapat diakses dengan operator tanda panah.

    Sekarang kita melihat contoh dari property dan method yang bersifat static:

    class MyClass {

    public static $data = 5;
    public $id;

    public function setData($data) {
    self::$data = $data;
    }

    public function getData() {
    return self::$data;
    }

    public function setId($id) {
    $this->id = $id;
    }

    public function getID() {
    return $this->id;
    }

    public static function staticGetData() {
    return self::$data;
    }
    }


    Dengan class di atas, kode-kode di bawah ini dapat dilakukan:

    echo MyClass::$data; // Mengeluarkan angka 5, tidak perlu melakukan intansiasi class
    echo MyClass::staticGetData() // Mengeluarkan angka 5, tidak perlu melakukan intansiasi class

    $x = new MyClass();
    $x->setId(3);

    echo $x->getId(); // Mengeluarkan angka 3, harus melakukan instansiasi sebelum dipanggil
    echo $x->getData(); // Mengeluarkan angka 5, harus melakukan instansiasi sebelum dipanggil


    Nah, sekarang beberapa contoh yang menarik untuk meningkatkan pemahaman terhadap pengaruh static deklarasi terhadap property di class:

    $x = new MyClass();
    $x->setId(3);
    $x->setData(12);

    // Print out nilai di X
    echo 'Nilai id di $x: ' . $x->getId() . ' -- nilai data di $x: ' . $x->getData() . '<br/>';

    $y = new MyClass();
    $y->setId(8);
    $y->setData(30);

    // Print out nilai di Y
    echo 'Nilai id di $y: ' . $y->getId() . ' -- nilai data di $y: ' . $y->getData() . '<br/>';

    // Sekarang kita coba lagi dengan nilai di X
    echo 'Nilai id di $x: ' . $x->getId() . ' -- nilai data di $x: ' . $x->getData() . '<br/>';


    Perhatikan baik-baik nilai yang dihasilkan, terutama nilai X di pemanggilan kedua dibandingkan dengan nilai Y. Dengan deklarasi static, property $data di X dan di Y merupakan dua hal yang sama. Perubahan di satu tempat akan merubah hal yang lain. Lalu, apa bagusnya hal tersebut?

    Beberapa hal yang dapat dilakukan dengan deklarasi static:
    1. Melakukan Singleton Pattern dimana sepanjang proses hanya terdapat satu instance dari class yang kita inginkan.

    2. Menggantikan $_GLOBAL variable. Karena kita bisa mengakses property static tersebut dari mana saja, kita bisa menggunakannya untuk menggantikan $_GLOBAL variable. Kelebihannya adalah kita mempunyai namespace karena property didefinisikan di dalam class. Artinya, kita bisa memiliki dua buah property static yang bernama $data di dua class yang berbeda dan tidak perlu khawatir saling bertabrakan. Contoh:

    class NumberOne {
    public static $data = 3;
    }

    class NumberTwo {
    public static $data = 'test';
    }

    echo "Value number one: " . NumberOne::$data;
    echo "Value number two: " . NumberTwo::$data;


    Semoga dapat menambah pengetahuan.

    Rabu, 19 November 2008

    Front Controller Pattern

    Mengapa kita membutuhkan pattern ini?

    Ketika sebuah aplikasi menangani permintaan service melalui titik masuk yang berbeda-beda, akan sangan sulit tentunya untuk menghindari duplikasi yang terjadi dalam programmnya. Sebagai contoh, ketika kita membutuhkan autentikasi terhadap user, maka proses autentikasi tersebut harus kita pastikan terjadi di berbagai titik masuk dari aplikasi kita. Jika ada titik masuk yang terlupa, tidak dilakukan autentikasi, aplikasi kita dapat diakses tanpa ada autentikasi. Masalahnya akan lebih besar lagi ketika kita harus melakukan perubahan terhadap proses autentikasi tersebut. Perubahan yang dibutuhkan, mau tidak mau, harus dilakukan di setiap titik yang membutuhkan autentikasi itu sendiri. Dengan cara ini, akan terdapat kemungkinan dimana beberapa bagian dari program kita terlupakan untuk diupdate. Tentunya kita dapat membuat library atau fungsi yang digunakan bersama-sama untuk menangani proses autentikasi tersebut, tetapi kita tetap harus memanggil fungsi tersebut dari beberapa titik masuk aplikasi kita.

    Permasalahan besar juga terjadi ketika kita harus menangani aplikasi yang memiliki alur penampilan (View) yang berbeda-beda. Untuk sistem yang kompleks, tampilan yang dikirimkan ke pengguna mungkin dibentuk oleh beberapa bagian yang berbeda, tergantung pada hasil berbagai proses di dalam aplikasi. Belum lagi jika bagian-bagian dari tampilan tersebut dapat digunakan dengan cara yang berbeda-beda. Ketika kita memiliki titik masuk yang banyak ke dalam aplikasi, mememecahkan proses penampilan tersebut menjadi pekerjaan yang tidak mudah untuk dilakukan.

    Untuk mengatasi permasalahan-permasalahan di atas, kita dapat menggunakan pattern yang disebut sebagai Front Controller Pattern. Pattern ini menyediakan satu titik masuk bagi keseluruhan aplikasi kita. Kemudian, Front Controller akan melakukan pemrosesan untuk menentukan siapa yang harus bertanggung jawab terhadap permintaan yang terjadi. Dengan cara ini, kita dapat menambahkan fungsi-fungsi seperti autentikasi, inisialisasi, penentuan bahasa atau theme di satu tempat dan mendapatkan hasilnya di seluruh bagian dari aplikasi kita.

    Implementasi

    Di sini kita akan membahas mengenai Front Controller Pattern dengan PHP. Yang kita butuhkan adalah sebuah class yang akan menerima request dari client dan kemudian berdasarkan request tersebut menentukan hal apa atau siapa yang bertanggung jawab untuk melakukan proses selanjutnya. Contoh dari controller tersebut dapat dilihat di potongan class di bawah.


    class FrontController {
    private $applicationHelper;

    private function __construct() {}

    static function run() {
    $instance = new self();
    $instance->init();
    $instance->handleRequest();
    }

    function init() {
    $applicationHelper = ApplicationHelper::getInstance();
    $applicationHelper->init();
    }

    function handleRequest() {
    $request = new Request();
    $router = new Router();
    $cmd = $router->resolve($request);

    $cmd->execute( $request );
    }
    }


    Ternyata tidak terlalu sulit menerapkan Front Controller Pattern di PHP. Tentunya akan lebih terasa manfaatnya jika kita menambahkan beberapa helper class yang akan membantu dalam tugas-tugas seperti autentikasi dll. Untuk menggunakan class di atas, di awal aplikasi (misal: index.php) kita dapat melakukan pemanggilan:

    require_once 'FrontController.php';
    FrontController::run();


    Mulai sekarang, semua request ke aplikasi kita akan ditangani oleh FrontController dan diteruskan ke pihak-pihak yang berwenang :) . Detail dari beberapa bagian di FrontController tersebut akan saya bahas di tulisan berikutnya.