Laravel 5 PHPUnit Memory Allocation Exhausted

I have suddenly the same issue. It has worked flawlessly for months.

Just to give you an update on how we solved the problem (We didn't really but we got it to work).

From digging into this problem, it looks like phpunit does not de-allocate the built application from memory (database, cache, compiled resources, and the business logic) after running a test class. This was becoming even more problematic when running our project through CircleCI (they have even less memory than your vagrant box)

To solve it we built a test runner php script. It scans the test directory, and runs each test case in its down command line instance of phpunit. That way the memory is freed up after every test case is run. The runner keeps track of successes, failures and errors and compiles a report at the end.

For code coverage we use phpunit to generate ".cov" files for every test class that get compiled into one report by the test runner (all of this is built in command line functionality from phpunit).

TLDR; not really a solution but a way to continue working on your project. if anyone has fixed this before, all input would be much appreciated.

phpUnit doesn't clean up after itself. So as tests grow, memory usage grows along with it, naturally... unless you clean up after the tests.

A nice way to do that is to include a teardown method in your own custom base testcase class as described here: http://kriswallsmith.net/post/18029585104/faster-phpunit

Just in case anyone else stumbles on this thread.

I had a high memory limit in my phpunit.xml file, but it was not applying. It looks like the config/local/app.php applies a 500Mb limit. Which will override any parameters you have for phpunit.

@JeremyFrench I am having the same issue, I tried the teardown suggested by @willvincent but that didn't work, so was hoping could find the place you edited in config/app.php? I couldn't find any 500mb limit applied anywhere in my config, what is the line of code you added to override the memory limit.

Ok my workaround was a couple of things:

I ran the test applying more memory: phpunit -d memory_limit=2048M

And there were some tests that I was using a var_dump or print_r, removing those automatically reduced the memory footprint

Running into the same issue, I did the following to get enough memory (in bootstrap/autoload.php):

if(env('APP_ENV') == 'testing') {
    ini_set('memory_limit', '2G');
}

because to me having to type in the memory limit every time I launch phpunit is unacceptable.

I tried the tearDown idea to no avail (I have also had to add a DB::disconnect() call in tearDown to keep from having too many connections to the database). Ideally I'd like to solve why it's using so much memory instead of just raising the memory limit, already my tests are taking over 1.5GB and I'm just getting started. All of my testing is using the laravel crawler to verify everything is working on the site.

If you're ok not have code isolation, you can use this to globalize your app and reuse it for all tests. Forwarning, this can cause all sorts of test interactions and means you have to remember to unmock things and do manual resets, but it does save a lot of memory and time...

/**
     * Creates the application.
     *
     * @return \Illuminate\Foundation\Application
     */
    public function createApplication()
    {
        global $app;

        if (is_null($app)) {
            $app = require __DIR__.'/../bootstrap/app.php';

            $app->make(\Illuminate\Contracts\Console\Kernel::class)->bootstrap();
        }

        return $app;
    }

To use this, you'll also want to override Laravel's default teardown with something like

/**
     * Closes down mockery
     */
    public function tearDown()
    {
        \Mockery::close();
        //parent::tearDown();
    }

Here's a sort of general overview of what this does from Laravel 4.2: https://github.com/laravel/framework/issues/1798

I'm wondering if you could save a bunch of RAM by having teardown unset $app or otherwise unload it using something like: http://kriswallsmith.net/post/18029585104/faster-phpunit

Another option is to run this test with the --process-isolation flag. It will slow down your tests but runs each test in a separate PHP process.

$phpunit tests --process-isolation

The process isolation trick seems to work, but does anyone know if there's some kind of big with phpunit + memory allocation? I'm monitoring our build server via our Grafana dashboard and I can see that it's using around 300mb of RAM at most, but it's crashing and saying "could not allocate more memory, 4gb used" or something. It's most certainly not allocating 4gb of ram to run these tests, but it thinks it is.

In our situation, some deployment / thirdparty systems don't give a lot of flexibility in how you can run phpunit. Although the phpunit.xml processIsolation="true" solution is probably the most elegant (should be the default?) it isn't always easily available.

The cleanup in the tearDown() worked for us.

Do NOT increase your php memory limit, as this just reinforces bad memory handling in your application. The typical web app should not require a higher memory limit (exceptions to this of course).

Using

    app()->forgetInstances();

in the teardown() method considerably reduced memory usage.

@dimit this solves my memory problems! Thank you!

Not sure if it's just because it's an old post or not but the advice is not useful, forgetInstances() is already run within when you run a test case in Laravel, flush() is called which removes instances amongst other things.

// src/Illuminate/Foundation/Testing/TestCase.php
     /**
     * Clean up the testing environment before the next test.
     *
     * @return void
     */
    protected function tearDown(): void
    {
        if ($this->app) {
            $this->callBeforeApplicationDestroyedCallbacks();

            $this->app->flush();

            $this->app = null;
        }
    }

// src/Illuminate/Container/Container.php
    /**
     * Clear all of the instances from the container.
     *
     * @return void
     */
    public function forgetInstances()
    {
        $this->instances = [];
    }

    /**
     * Flush the container of all bindings and resolved instances.
     *
     * @return void
     */
    public function flush()
    {
        $this->aliases = [];
        $this->resolved = [];
        $this->bindings = [];
        $this->instances = [];
        $this->abstractAliases = [];
    }