Getting into testing at work with one of our new projects, and we need to be able to test our services. The biggest problem I had here, is that we have several services not in the default scope. After a little bit of digging and testing, I came up with this:

#LANG:php
<?php
/**
 * @author    Aaron Scherer <aaron@undergroundelephant.com>
 * @date      2013
 * @copyright Underground Elephant
 */
namespace Ue\Bundle\RenderBundle\Tests\Service;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpFoundation\Request;

use Ue\Bundle\RenderBundle\Service\RequestService;

/**
 * RequestServiceTest Class
 */
class RequestServiceTest extends WebTestCase
{

	/**
	 * @var RequestService
	 */
	private $requestService;

	/**
	 * @var
	 */
	private $container;

	/**
	 * {@inheritDoc}
	 */
	public function setUp()
	{
		$container = $this->getContainer();
		$container->enterScope( 'request' );
		$request = Request::create( '/t/1/' );
		$session = $this->getMock( 'Symfony\Component\HttpFoundation\Session\SessionInterface' );
		$request->setSession( $session );
		$this->getContainer()->set( 'request', $request );

		$this->requestService = $this->container->get( 'ue.render.request' );
	}

	/**
	 * {@inheritDoc}
	 */
	public function tearDown()
	{
		$this->getContainer()->leaveScope('request');
	}

	/**
	 * @return mixed
	 */
	public function getContainer()
	{
		if ( $this->container ) {
			return $this->container;
		}

		static::$kernel = static::createKernel( );
		static::$kernel->boot();

		$this->container = static::$kernel->getContainer();

		return $this->container;
	}

	/**
	 * Testing the constructor, and service call
	 */
	public function testRequestService()
	{

		$expected = 'Ue\Bundle\RenderBundle\Service\RequestService';
		$this->assertInstanceOf(
			$expected,
			$this->requestService,
			sprintf( "Expected %s for requestService. Got %s.", $expected, get_class( $this->requestService ) )
		);
	}

	/**
	 * @depends testRequestService
	 */
	public function testBuildRequest()
	{
		$this->requestService->setTestId( 1 );

		$expected = 'Ue\Bundle\RenderBundle\Model\Request';
		$request  = $this->requestService->buildRequest();
		$this->assertInstanceOf(
			$expected,
			$request,
			sprintf( "Expected %s for response from buildRequest(). Got %s instead.", $expected, get_class( $request ) )
		);
	}
}

This creates the request (which you need to get the service), sets up the kernel, and because our RequestService is in the request scope, enters the request scope with $container->enterScope( 'request' );.

Getting into testing at work with one of our new projects, and we need to be able to test our services. The biggest problem I had here, is that we have several services not in the default scope. After a little bit of digging and testing, I came up with this

Symfony2 Testing: Testing Services in Request Scope

Basically, we wanted to be able to use a simple Reverse Proxy (not Varnish, not Squid), that used a Memcache installation, instead of the file system.

I wrote a new MemcachedStore class that AppCache now uses instead. The biggest downside is, the configs for the servers aren't used by the AppCache piece.

Heres the MemcachedStore class. Right now, it's set up to use my AequasiMemcachedBundle Symfony bundle at the moment, but it wouldn't be that hard to change to just using Memcached or Memcache.

Then, in app/AppCache.php, do the following:

Require the MemcachedStore class at the top

#LANG:php
<?php 

require_once __DIR__ . '/AppKernel.php';
require_once __DIR__ . '/MemcachedStore.php';

class AppCache
{
	// ...

#LANG:php
<?php
//...
class AppCache
{
    // ...
    public function createStore()
    {
        $servers = [
            [ 'localhost', 11211 ]
        ];
    
        return new MemcachedStore( [
            'enabled'      => true,
            'debug'        => true,
            'persistentId' => serialize( $servers )
        ], $servers );
    }
    // ...
}

If you want to create a service to get to this particular store, you would have to create a $cache variable in your app/AppKernel, and overwrite your app/AppCache's handle() method to set the kernel's $cache variable before calling parent::handle.

At my work, we deal with a project where we have several development servers, a few staging servers, and hundreds of production servers.

Having to deal with all four different environment types, without having environments hardcoded into the project is a little weird, and currently lacks much any real solutions, regarding symfony's documentation.

In short, I implemented a class that we use in app/console and web/app.php, that reads an Apache environment variable or a php.ini variable with get_cfg_var().

I've recently moved the code to a new repository:
http://www.github.com/aequasi/environment-php

Like I said above, I made an Environment class to check what environment the server belongs in. I made it a gist for you guys: https://gist.github.com/5753723.git.

Basically, this environment class, can take an ArgvInput param as a constructor, and if it does, it assumes that it's CLI. If it's CLI, it will do the same CLI checks the symfony does by default for $env, and $debug. Cli and web both allow for specifying symfony.environment in php.ini as well, and the web piece allows you to specify an apache env variable (e.g. SetEnv SYM_ENV stage).

Once you've got that code, place it into app/Environment.php (you'll have to create it). From there, copy the logic I've got for app/consle and web/app.php below.

#LANG:ini
[symfony]
symfony.environment = staging


#LANG:php
<?php
set_time_limit(0);

require_once __DIR__.'/bootstrap.php.cache';
require_once __DIR__.'/AppKernel.php';
require_once __DIR__ .'/../app/Environment.php';

use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Input\ArgvInput;

$input = new ArgvInput( );
$env = new \Environment( $input );


$kernel = new AppKernel( $env->getEnvironment(), $env->getDebug() );
$application = new Application($kernel);
$application->run( $input );


#LANG:php
<?php

use Symfony\Component\HttpFoundation\Request;

$loader = require_once __DIR__.'/../app/bootstrap.php.cache';
require_once __DIR__.'/../app/AppKernel.php';
require_once __DIR__ .'/../app/Environment.php';

$env = new \Environment();

$kernel = new AppKernel( $env->getEnvironment(), $env->getDebug() );
$kernel->loadClassCache();
Request::enableHttpMethodParameterOverride();
$request = Request::createFromGlobals();
$response = $kernel->handle($request);
$response->send();
$kernel->terminate($request, $response);

Dealing with a project where there are several development servers, a few staging servers, and hundreds of production servers. Manage your environments easily!

Better Symfony Environments: Large Systems

So, I started work on a personal project of mine that I wanted to be able to use Memcached. The project is using the Symfony2 PHP framework, so I decided to look around a little bit to see if I could find a bundle that does what I needed.

I stumbled upon the LswMemcacheBundle at first, and it looked quite nice, having features like Anti Dog Pile, and Profiling attached to the Web Profiler Toolbar. I started looking at the code however, and it had a lot of bloat that I didnt want, some of the terminologies werent right, and it was missing a feature that I wanted. So I took it and decided to write my own.

So now, I give you the AequasiMemcachedBundle! This takes a lot of the core logic, and features of the LswMemcacheBundle, but removes the ability to use the Memcache extension, and the compatibility with Memcached versions below 2.0.

To install this bundle, check out the source here, and follow the instructions in the readme.

So, I started work on a personal project of mine that I wanted to be able to use Memcached. The project is using the Symfony2 PHP framework, so I decided to look around a little bit to see if I could find a bundle that does what I needed

Aaron Scherer

Symfony2 Testing: Testing Services in Request Scope

Symfony Reverse Proxy: Memcached

Better Symfony Environments: Large Systems

Symfony 2 and Memcached: A new Bundle