Well, the assumption that there is no controller is wrong. There is one, the PagesController, though by default it is “hidden” in cake/libs/controller (unless you baked your project with the bake script, then you will also find a PagesController in app/controllers).

And this means you can specify the helpers you want to use in your static pages in the usual way: by adding them to the $helpers array of the PagesController resp. the AppController (app/app_controller.php), if you want to use the helpers in the views of more than one controller. Please do not edit the PagesController in the cake/libs/controller directory, but copy it to app/controllers and make the changes there.

The obvious way is to use the following approach:

$myController = new ExampleController();
$myController->test();

If you are “lucky” and you do not use components or models in the called method, then the snippet above works fine. In the other case, you will get a “Call to a member function on a non-object” error.

The reason for this error is that the models and components used by the controller are not constructed when you create a new instance of the controller. For this purpose you have to call the constructClasses() method before you use any controller methods. We can now rewrite the example from above to:

$myController = new ExampleController();
$myController->constructClasses();
$myController->test();

This probably works in most cases. I say “probably”, because if the used components use callback methods like initialize() or startUp(), then you have to call those callbacks yourself. The same is true if you want to use the beforeFilter() and afterFilter() callbacks in your controller.

Here an example with calling the initialize() callback method of the components (“Component” is misnamed, it is in fact a container which contains all components a controller uses):

$myController = new ExampleController();
$myController->constructClasses();
$myController->Component->initialize($myController);
$myController->test();

This is a bit ugly, because you have to know implementation details of the controller you shouldn’t have to know…

Anyway, if you are interested in the complete instantiation and initialization process of a controller, have a look at Dispatcher::dispatch() and Dispatcher::_invoke().

This leads us to an alternative to the instantiation of a controller: to use a controller method indirectly by using Dispatcher::dispatch(). The example would then look like:

$dispatcher = new Dispatcher();
$dispatcher->dispatch('/example/test');

It depends on your specific use case whether this is a possible alternative, as with this approach you no longer have direct access to the respective controller.

Anyway, happy baking!

You can find additional information about testing controllers in the cookbook.

Happy testing :)

And that’s what I did. Here is the result:

public function index() {
    App::import('Controller', 'Example');
    $example = new ExampleController();
    $example->constructClasses();
    $foo = $example->getFoo();
    // do something with $foo
}

The only “difficulty” is that you have to “manually” load the models and components used by the respective controller with constructClasses().

It seems to work fine and it is faster than requestAction, but it is possible that some callback methods are not called (at least the shutdown() callback of components is not called). So, be careful with this approach. And think twice before using this approach or requestAction ;-)

And so I looked for a different approach and ended up with a modified PagesController, combined with a route. The idea is to use the convention that each file in app/views/pages can be accessed like example.com/file (i.e. about.ctp is accessed as example.com/about and about/company.ctp as example.com/about/company).

Here is the PagesController:

// app/controllers/pages_controller.php
class PagesController extends AppController{
    public $uses = array();

    public function display() {
        $viewFilename = array_pop($this->params['pass']) . '.ctp';
        $viewFilename = str_replace('-', '_', $viewFilename);

        $viewPath =  DS . $viewFilename;
        if ($this->params['pass']) {
            $viewPath = DS . implode(DS, $this->params['pass']) . $viewPath;
        }

        if (file_exists(VIEWS.'pages'.$viewPath)) {
            $this->render(null, null, VIEWS.'pages'.$viewPath);
        } else {
            $this->cakeError('error404');
        }
    }
}

To get the aforementioned URL scheme we have to define a “catch all” route in app/config/routes.php:

Router::connect('*', array('controller' => 'pages', 'action' => 'display'));

This route has to be the latest route in the routes file. And that’s also the disadvantage of this approach: because of the “catch all” route you have to define routes for all controllers…

Anyway, I hope this approach is useful for some of you :)

The first two approaches use the magic variable “title_for_layout” to set the title in the layout:

<title>
    <?php echo $title_for_layout;?>
</title>

You can set the value for this magic variable either in the controller:

public $pageTitle = 'The title';  // same title for all actions

or

public function test() {
    $this->pageTitle = 'The title';
    ...
}

or in the view file:

<?php $this->pageTitle = 'The title';?>
...

The third, and last, approach uses a custom variable in the layout instead of the magic variable:

<title>
    <?php echo $pageTitle;?>
</title>

Its value is then set in the controller, in the same way you put other data to the view:

public function test() {
    ...
    $this->set('pageTitle', 'The title');
}

Now, which approach should you use? I think it is a matter of preference. From a conceptual point of view I prefer the third approach as it doesn’t use any magic, but in practice I usually use the second (maybe this will change after this article *g*). The first approach I consider as a bad practice, because a controller doesn’t represent a page and hence it shouldn’t have a pageTitle property.

To prevent this effect, we have to detect the type of view which is rendered. The only way I found to accomplish this, is to check the viewPath, as shown in the following snippet:

// in app/app_controller.php
public function beforeRender() {
    if ($this->viewPath != 'errors') {
        // no error page
    }
}

It is probably rather rare you have to use this, but maybe it is useful for some.

cake bake model User
cake bake controller Users scaffold
cake bake view Users

For more details on those shortcuts call the bake script with the help parameter like:

cake bake model help

or have a look at Faster baking of controllers with the bake shell script and Baking views.

Recently, a new shortcut was added which makes the aforementioned shortcuts (almost) obsolete. With the “all” parameter it is now possible to bake with one command a model plus the corresponding controller with its views:

cake bake all  // asks you for the model name
cake bake all User

This feature is currently only available in the development branch, but the next release is probably not that far away…

Happy baking :)

$this->redirect('/controller/action', null, true);

or

$this->redirect('/controller/action');
exit();

Thanks to a recent change of the API of the “redirect” method — the default value for the $exit parameter was changed from “false” to “true” — you can now simply use:

$this->redirect('/controller/action');

As it does an exit() by default, you can no longer encounter a possible security hole I described in Don’t forget to exit after a redirect (well, theoretically you can still encounter it when setting the $exit parameter explicitly to “false”, but that’s rather unlikely I think).

Merry Christmas to everyone!

PS: From the activity in the repository it looks like the Cake team is baking a Christmas Cake :)

In the meantime this feature has been added to the development branch (I don’t know when) as I learned today from a comment by gwoo.

If you have an element /app/views/elements/example.ctp in your application, then you can render it with the following code snippet from within your controller:

$this->render('/elements/example');

In the same way you can also render views which belong to other controllers.