RueDesJuristes

It is a web application offering juridic services for french societies. It allow creation, modification and liquidation of these legal entities. Its website can be found here at ruedesjuristes.com.

It’s done entirely in PHP using the Kohana framework.

This was the first time I would be working with Twig. It was a really nice experience. Development was extremely fast and I would no lie saying it has never bugged me. I did unit testing with PHPUnit and Kohana Request, which is surprisingly efficient.

Just to say, Twig is a template engine produced by SensioLabs. It was originally built for the Symphony framework, but it can be combined with any of your favorite tool. Since I use the Kohana framework, you should look for this Twig module written by tommcdo.

I’ve been a little frustrated with errors handling when I had some mistakes in my Twig syntax. When you get an error in a parsing tree and your debugger print humongous structure recursively, you get out of memory quite quickly. To avoid this, you may reduce the depth of recursion in Debug::dump by overloading it.

The great thing about Kohana is its cascading file system (CFS), which allow us to override its default behiaviours.


1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php

defined('SYSPATH') or die('No direct script access.');

class Debug extends Kohana_Debug {

    /**
     * Reducing the default $depth from 10 to 2 to avoid reaching memory limit.
     */
    public static function dump($value, $length = 128, $depth = 2) {

        return parent::dump($value, $length, $depth);
    }
}

If you work with light templates, you should be fine with the default depth. It is something to consider only if you reach the memory limit.

JSON really saved me here! The website collects an big amount of data to proceed the legal formalities. User have to submit forms with around 60 inputs. All the data are serialized once using json_encode. I used the ORM::filters feature to serialize the data on need.

Form can also be submitted in ajax. To do so, you may use Request::is_ajax and disable template rendering by setting Request::$auto_render to FALSE. I usually encode ORM_Validation_Exception errors if anything wrong happen: they are well structured and translated, so it becomes a charm to map errors to input!


1
2
3
4
5
6
7
8

<?php

if ($this->request->is_ajax()) {

    $this->auto_render = FALSE;

    $this->response->body(json_encode($errors));
}

Improvements in the mail module

The project also permitted me to upgrade my mailing module. I could consider it as a really nice piece of software. It has a lovely closure syntax:


1
2
3
4
5
6
7

<?php

Mailer::factory()
    ->content_type('text/html; charset=utf-8')
    ->subject('Hey Foo!')
    ->body(Twig::factory('some/template'))
    ->send('foo@example.com');

It is also parsing recipient list using a nice regex, so you do not have to worry sending more personal mail to your user, even if they have non-ascii username. It the worst case, it defaults to his email.

Moreover, it supports attachment, so whenever you need to append a legal document or an alternate message:


1
2
3
4
5

<?php

Mailer::factory()
    ->attachment($document->content, array('Content-Type' => $document->content_type))
    ->send($user->email);

PHPUnit and self-requesting

Kohana is HMVC, which means that you can request any of your page in the execution of any internal Request. This is extremly convenient when testing an application, since it generally ends up being about requesting an endpoint and asserting the new states of your data.


1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php

defined('SYSPATH') or die('No direct script access.');

class HomeTest extends Unittest_TestCase {

    public function testIndex() {

        $response = Request::factory('')->execute();

        $this->assertEquals(200, $response->status());
        $this->assertTag(array('tag' => 'h1', 'content' => 'Hello world!'), $response->body());
        // ...
}

Even the mail module is fully testable using Mail_Sender_Mock. It is a nice feature that simulates a mailing driver. It speeds up considerably the testing as you don’t need to wait for Sendmail.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?php

defined('SYSPATH') or die('No direct script access.');

class HomeTest extends Unittest_TestCase {

    public function testMail() {

        $response = Request::factory('mail')
            ->method(Request::POST)
            ->values(array('email' => 'foo@example.com'))
            ->execute();

        $mail = array_pop(Mail_Sender_Mock::$history);

        $this->assertEquals('text/html', $mail->content_type());
        $this->assertContains('foo@example.com', $mail->to);
        $this->assertTag(array('tag' => 'h1', 'content' => 'Hello world!'), $mail->body());
        // ...
}

The website implements a payment solution based on PayPal. I did some work on a PayPal module I have written, which has become a simple external Request factory. It is much more convenient this way then how it was before, since it reuses the code from Kohana.

I also improved the IPN implementation. It was a little buggy, since I never really used it, but now it is fully working and tested!

Fixtures

Fixtures are really nicely done. I’ve overloaded Unittest_TestCase to add some on-the-fly ORM generators. For instance, if you need a user to test the login action:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?php

defined('SYSPATH') or die('No direct script access.');

class Unittest_TestCase extends Kohana_Unittest_TestCase {

    public function getUser() {

        return ORM::factory('User')
            ->values(array(
                'username' => uniqid(),
                'email' => uniqid() . '@ruedesjuristes.com',
                'password' => 'abcd1234'
            ))
            ->add('roles', ORM::factory('Role', array('name' => 'login')));
    }
}

Then, anytime you need a user in your tests,


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?php

public function testLogin() {

    $user = $this->getUser();
    $this->assertFalse(Auth::instance()->logged_in());

    $response = Request::factory()
        ->method(Request::POST)
        ->post(array(
            'username' => $user->username,
            'password' => 'abcd1234'
        ))->execute();

    $this->assertTrue(Auth::instance()->logged_in());
    $this->assertEquals($user->pk(), Auth::instance()->get_user()->pk());
}

This is much better, in my opinion, than rely on Unittest_Database_TestCase for an ORM based application.

Coverage

It is also the first time I’ve experienced test coverage and honestly, what an amazing tool. It pretty much analyze your code while tests are running and outputs statistics about code complexity and percentage of line execution. Untested code is likely not to work, so having a good coverage is really important.

This project shown me tools that made the development considerably faster and fun. Having not to debug was probably the best thing I’ve experienced so far. Also, delivering a high quality web app really changed the way I’ve been seeing the development process.