Issues in CollectionTest.php (master) - Issues in master - consolidation/robo - Measure and Improve Code Quality continuously with Scrutinizer

Issues (569)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

tests/integration/CollectionTest.php (24 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
namespace Robo;

use PHPUnit\Framework\TestCase;
use Robo\Collection\Temporary;
use Robo\Exception\AbortTasksException;
use Robo\Traits\TestTasksTrait;

class CollectionTest extends TestCase
{
    use TestTasksTrait;
    use Collection\loadTasks;
    use Task\File\loadTasks;
    use Task\Filesystem\loadTasks;
    use Task\Filesystem\loadShortcuts;
    use Task\TestHelperTasks;

    protected $fixtures;

    public function setUp()
    {
        $this->fixtures = new Fixtures();
        $this->initTestTasksTrait();
        $this->fixtures->createAndCdToSandbox();
    }

    public function tearDown()
    {
        $this->fixtures->cleanup();
    }

    public function testSimulateDirCreation()

    {
        // Set up a collection to add tasks to
        $collection = $this->collectionBuilder();
        $collection->simulated(true);

        // Set up a filesystem stack
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->mkdir('simulatedir')
            ->touch('simulatedir/error.txt');

        // Run the task collection; the files would be present were this
        // operation not simulated.
        $result = $collection->run();
        $this->assertTrue($result->wasSuccessful());
        // Nothing should be created in simulated mode
        $this->assertFileNotExists('simulatedir/error.txt');
        $this->assertOutputContains('[Simulator] Simulating Filesystem\FilesystemStack()');
    }


    public function testRunMultipleTasksViaACollectionBuilder()
    {
        // This tests creating multiple tasks in a single builder,
        // which implicitly adds them to a collection.  To keep things
        // simple, we are only going to use taskFilesystemStack.  It
        // would be possible, of course, to do these operations with
        // a single FilesystemStack, but our goal is to test creating
        // multiple tasks with a builder, and ensure that a propper
        // collection is built.
        $collection = $this->collectionBuilder();
        $result = $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->mkdir('a')
                ->touch('a/a.txt')
            ->rollback(
                $this->taskDeleteDir('a')
            )
            ->taskFilesystemStack()
                ->mkdir('a/b')
                ->touch('a/b/b.txt')
            ->taskFilesystemStack()
                ->mkdir('a/c')
                ->touch('a/c/c.txt')
            ->run();

        $this->assertTrue($result->wasSuccessful(), $result->getMessage());

        $this->assertEquals(0, $result->getExitCode());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileExists('a');
        $this->assertFileExists('a/a.txt');
        $this->assertFileExists('a/b');
        $this->assertFileExists('a/b/b.txt');
        $this->assertFileExists('a/c');
        $this->assertFileExists('a/c/c.txt');
    }

    public function testUsingAWorkingDirWithACollectionBuilder()
    {
        // Run the same test with a working directory.  The working
        // directory path will point to a temporary directory which
        // will be moved into place once the tasks complete.
        $collection = $this->collectionBuilder();
        $workDirPath = $collection->workDir("build");
        $this->assertNotEquals("build", basename($workDirPath));
        $result = $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->mkdir("{$workDirPath}/a")
                ->touch("{$workDirPath}/a/a.txt")
            ->taskFilesystemStack()
                ->mkdir("{$workDirPath}/a/b")
                ->touch("{$workDirPath}/a/b/b.txt")
            ->taskFilesystemStack()
                ->mkdir("{$workDirPath}/a/c")
                ->touch("{$workDirPath}/a/c/c.txt")
            ->run();

        $this->assertTrue($result->wasSuccessful(), $result->getMessage());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileExists('build/a');
        $this->assertFileExists('build/a/a.txt');
        $this->assertFileExists('build/a/b');
        $this->assertFileExists('build/a/b/b.txt');
        $this->assertFileExists('build/a/c');
        $this->assertFileExists('build/a/c/c.txt');
    }

    public function testRollbackAfterFailureViaACollectionBuilder()

    {
        // This is like the previous test, toRunMultipleTasksViaACollectionBuilder,
        // except we force an error at the end, and confirm that the
        // rollback function is called.
        $collection = $this->collectionBuilder();
        $result = $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->mkdir('j')
                ->touch('j/j.txt')
            ->rollback(
                $this->taskDeleteDir('j')
            )
            ->taskFilesystemStack()
                ->mkdir('j/k')
                ->touch('j/k/k.txt')
            ->taskFilesystemStack()
                ->mkdir('j/k/m')
                ->touch('j/k/m/m.txt')
            ->taskCopyDir(['doesNotExist' => 'copied'])
            ->run();

        $this->assertEquals(1, $result->getExitCode(), $result->getMessage());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileNotExists('q/q.txt');
        $this->assertFileNotExists('j/j.txt');
        $this->assertFileNotExists('j/k/k.txt');
        $this->assertFileNotExists('j/k/m/m.txt');
    }

    public function testAbortRollbackOrCompletion()

    {
        // This is like the previous test, except we throw a ForcedException()
        // inside the rollback to abort the rollback.
        $collection = $this->collectionBuilder();
        $result = $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->mkdir('j')
            ->touch('j/j.txt')
            ->rollback(
                $this->taskDeleteDir('j')
            )
            ->rollbackCode(function () {
                throw new AbortTasksException('Aborting rollback.');
            })
            ->taskFilesystemStack()
            ->mkdir('j/k')
            ->touch('j/k/k.txt')
            ->taskFilesystemStack()
            ->mkdir('j/k/m')
            ->touch('j/k/m/m.txt')
            ->taskCopyDir(['doesNotExist' => 'copied'])
            ->run();

        $this->assertEquals(1, $result->getExitCode(), $result->getMessage());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileExists('j/j.txt');
        $this->assertFileExists('j/k/k.txt');
        $this->assertFileExists('j/k/m/m.txt');
    }

    public function testRollbackAWorkingDir()
    {
        // Run the same test with a working directory.  The working
        // directory path will point to a temporary directory which
        // will be moved into place once the tasks complete.
        $collection = $this->collectionBuilder();
        $workDirPath = $collection->workDir("build");
        $this->assertNotEquals("build", basename($workDirPath));
        $result = $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->mkdir("{$workDirPath}/a")
                ->touch("{$workDirPath}/a/a.txt")
            ->taskFilesystemStack()
                ->mkdir("{$workDirPath}/a/b")
                ->touch("{$workDirPath}/a/b/b.txt")
            ->taskFilesystemStack()
                ->mkdir("{$workDirPath}/a/c")
                ->touch("{$workDirPath}/a/c/c.txt")
            ->taskCopyDir(['doesNotExist' => 'copied'])
            ->run();

        $this->assertEquals(1, $result->getExitCode(), $result->getMessage());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileNotExists('build/a');
        $this->assertFileNotExists($workDirPath);
    }

    public function testBuildFilesViaAddIterable()
    {
        $processList = ['cats', 'dogs', 'sheep', 'fish', 'horses', 'cows'];

        $collection = $this->collectionBuilder();
        $result = $collection
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->taskFilesystemStack()
                ->mkdir('stuff')
            ->taskForEach($processList)
                ->withBuilder(
                    function ($builder, $key, $value) {
                        return $builder
                            ->taskFilesystemStack()
                                ->touch("stuff/{$value}.txt");
                    }
                )
            ->run();

        $this->assertEquals(0, $result->getExitCode(), $result->getMessage());

        $this->assertFileExists('stuff/cats.txt');
        $this->assertFileExists('stuff/dogs.txt');
        $this->assertFileExists('stuff/sheep.txt');
        $this->assertFileExists('stuff/fish.txt');
        $this->assertFileExists('stuff/horses.txt');
        $this->assertFileExists('stuff/cows.txt');
    }

    public function testRollbackANestedCollection()
    {
        // This is like the previous test, toRunMultipleTasksViaACollectionBuilder,
        // except we force an error at the end, and confirm that the
        // rollback function is called.
        $collection = $this->collectionBuilder();
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->mkdir('j')
                ->touch('j/j.txt')
            ->rollback(
                $this->taskDeleteDir('j')
            )
            ->taskFilesystemStack()
                ->mkdir('j/k')
                ->touch('j/k/k.txt')
            ->taskFilesystemStack()
                ->mkdir('j/k/m')
                ->touch('j/k/m/m.txt');

        $result = $this->collectionBuilder()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->taskFilesystemStack()
                ->mkdir('q')
                ->touch('q/q.txt')
            ->addTask($collection)
            ->taskCopyDir(['doesNotExist' => 'copied'])
            ->run();

        $this->assertEquals(1, $result->getExitCode(), $result->getMessage());

        // All of the tasks created by the builder should be added
        // to a collection, and `run()` should run them all.
        $this->assertFileExists('q/q.txt');
        $this->assertFileNotExists('j/j.txt');
        $this->assertFileNotExists('j/k/k.txt');
        $this->assertFileNotExists('j/k/m/m.txt');
    }

    public function testRollbackInCorrectOrder()
    {
        $expected_order = [6,5,4,3,2,1];
        $actual_order = [];
        $collection = $this->collectionBuilder();
        $collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 1;
        });
        $collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 2;
        });
        $collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 3;
        });
        // Add a nested collection with rollbacks.
        $nested_collection = $this->collectionBuilder();
        $nested_collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 4;
        });
        $nested_collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 5;
        });
        $collection->addTask($nested_collection);

        $collection->rollbackCode(function () use (&$actual_order) {
            $actual_order[] = 6;
        });
        $collection->addCode(function () {
            return Result::EXITCODE_ERROR;
        });
        $result = $collection->run();
        $this->assertFalse($result->wasSuccessful(), $result->getMessage());
        $this->assertEquals($expected_order, $actual_order);
    }

    public function testCreateDirViaCollection()

    {
        // Set up a collection to add tasks to
        $collection = $this->collectionBuilder();

        // Set up a filesystem stack
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->mkdir('log')
            ->touch('log/error.txt');

        // FilesystemStack has not run yet, so file should not be found.
        $this->assertFileNotExists('log/error.txt');

        // Run the task collection; now the files should be present
        $result = $collection->run();
        $this->assertTrue($result->wasSuccessful(), $result->getMessage());
        $this->assertFileExists('log/error.txt');
        $this->assertFileExists('log');
    }

    public function testUseATmpDirAndConfirmItIsDeleted()
    {
        // Set up a collection to add tasks to
        $collection = $this->collectionBuilder();

        // Get a temporary directory to work in. Note that we get a
        // name back, but the directory is not created until the task
        // runs.  This technically is not thread-safe, but we create
        // a random name, so it is unlikely to conflict.
        $tmpPath = $collection->tmpDir();

        // Set up a filesystem stack, but use a collection to defer execution
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->mkdir("$tmpPath/tmp")
            ->touch("$tmpPath/tmp/error.txt")
            ->rename("$tmpPath/tmp", "$tmpPath/log");

        // Copy our tmp directory to a location that is not transient
        $collection->taskCopyDir([$tmpPath => 'copied']);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        // FilesystemStack has not run yet, so no files should be found.
        $this->assertFileNotExists("$tmpPath/tmp/error.txt");
        $this->assertFileNotExists("$tmpPath/log/error.txt");
        $this->assertFileNotExists('copied/log/error.txt');

        // Run the task collection
        $result = $collection->run();
        $this->assertEquals(0, $result->getExitCode(), $result->getMessage());
        $this->assertEquals($result['path'], $tmpPath, "Tmp dir result matches accessor.");

        // The file 'error.txt' should have been copied into the "copied" dir.
        // This also proves that the tmp directory was created.
        $this->assertFileExists('copied/log/error.txt');
        // $tmpPath should be deleted after $collection->run() completes.
        $this->assertFileNotExists("$tmpPath/tmp/error.txt");
        $this->assertFileNotExists("$tmpPath/log/error.txt");
        $this->assertFileNotExists("$tmpPath");
    }

    public function testUseATmpDirAndChangeWorkingDirectory()
    {
        // Set up a collection to add tasks to
        $collection = $this->collectionBuilder();

        $cwd = getcwd();

        $tmpPath = $collection->taskTmpDir()

            ->cwd()
            ->getPath();

        // Set up a filesystem stack, but use a collection to defer execution.
        // Note that since we used 'cwd()' above, the relative file paths
        // used below will be inside the temporary directory.
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->mkdir("log")
            ->touch("log/error.txt");

        // Copy our tmp directory to a location that is not transient
        $collection->taskCopyDir(['log' => "$cwd/copied2"]);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        // FilesystemStack has not run yet, so no files should be found.
        $this->assertFileNotExists("$tmpPath/log/error.txt");
        $this->assertFileNotExists('$cwd/copied2/log/error.txt');

        // Run the task collection
        $result = $collection->run();
        $this->assertEquals(0, $result->getExitCode(), $result->getMessage());

        // The file 'error.txt' should have been copied into the "copied" dir
        $this->assertFileExists("$cwd/copied2/error.txt");
        // $tmpPath should be deleted after $collection->run() completes.
        $this->assertFileNotExists("$tmpPath/log/error.txt");
        // Make sure that 'log' was created in the temporary directory, not
        // at the current working directory.
        $this->assertFileNotExists("$cwd/log/error.txt");

        // Make sure that our working directory was restored.
        $finalWorkingDir = getcwd();
        $this->assertEquals($cwd, $finalWorkingDir);
    }

    public function testCreateATmpFileAndConfirmItIsDeleted()
    {
        // Set up a collection to add tasks to
        $collection = $this->collectionBuilder();

        // Write to a temporary file. Note that we can get the path
        // to the tempoary file that will be created, even though the
        // the file is not created until the task collecction runs.
        $tmpPath = $collection->taskTmpFile('tmp', '.txt')
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->line("This is a test file")
            ->getPath();

        // Copy our tmp directory to a location that is not transient
        $collection->taskFilesystemStack()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->copy($tmpPath, 'copied.txt');

        // FilesystemStack has not run yet, so no files should be found.
        $this->assertFileNotExists("$tmpPath");
        $this->assertFileNotExists('copied.txt');

        // Run the task collection
        $result = $collection->run();
        $this->assertEquals(0, $result->getExitCode(), $result->getMessage());

        // The file 'copied.txt' should have been copied from the tmp file
        $this->assertFileExists('copied.txt');
        // $tmpPath should be deleted after $collection->run() completes.
        $this->assertFileNotExists("$tmpPath");
    }

    public function testUseATmpDirWithAlternateSyntax()
    {
        $collection = $this->collectionBuilder();

        // This test is equivalent to toUseATmpDirAndConfirmItIsDeleted,
        // but uses a different technique to create a collection of tasks.
        $tmpPath = $collection->tmpDir();

        // Now, rather than creating the tasks with a collection builder,
        // which automatically adds the tasks to the collection as they are
        // created, we will instead create them individually and then add
        // them to the collection via the addTaskList() method.
        $result = $collection->addTaskList(
            [
                $this->taskFilesystemStack()->mkdir("$tmpPath/log")->touch("$tmpPath/log/error.txt"),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $this->taskCopyDir([$tmpPath => 'copied3']),
            ]
        )->run();

        // The results of this operation should be the same.
        $this->assertEquals(0, $result->getExitCode(), $result->getMessage());
        $this->assertFileExists('copied3/log/error.txt');
        $this->assertFileNotExists("$tmpPath/log/error.txt");
    }

    public function testCreateATmpDirWithoutACollection()
    {
        // Create a temporary directory, using our function name as
        // the prefix for the directory name.
        $tmpDirTask = $this->taskTmpDir(__FUNCTION__);
        $tmpPath = $tmpDirTask->getPath();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->assertFileNotExists($tmpPath);
        $result = $tmpDirTask->run();
        $this->assertTrue($result->wasSuccessful(), $result->getMessage());
        $this->assertFileExists($tmpPath);
        // Creating a temporary directory without a task collection will
        // cause the temporary directory to be deleted when the program
        // terminates.  We can force it to clean up sooner by calling
        // TransientManager::complete(); note that this deletes ALL global tmp
        // directories, so this is not thread-safe!  Useful in tests, though.
        Temporary::complete();
        $this->assertFileNotExists($tmpPath);
    }

    public function testCreateATmpDirUsingShortcut()
    {
        // Create a temporary directory, using our function name as
        // the prefix for the directory name.
        $tmpPath = $this->_tmpDir(__FUNCTION__);
        $this->assertFileExists($tmpPath);
        // Creating a temporary directory without a task collection will
        // cause the temporary directory to be deleted when the program
        // terminates.  We can force it to clean up sooner by calling
        // TransientManager::complete(); note that this deletes ALL global tmp
        // directories, so this is not thread-safe!  Useful in tests, though.
        Temporary::complete();
        $this->assertFileNotExists($tmpPath);
    }

    public function testThrowAnExceptionAndConfirmItIsCaught()
    {
        $collection = $this->collectionBuilder();

        $collection->addCode(
            function () {
                throw new \RuntimeException('Error');
            }
        );
        $result = $collection->run();
        $this->assertEquals('Error', $result->getMessage());
        $this->assertEquals(1, $result->getExitCode());
    }

    public function testChainData()
    {
        $collection = $this->collectionBuilder();

        $result = $collection
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->taskValueProvider()
                ->provideMessage('1st') // Sets Result's message to '1st'
                ->storeState('one') // Copy Result's message to $state['one']
            ->taskValueProvider()
                ->provideMessage('2nd')
                ->storeState('two')
            ->taskValueProvider()
                ->deferTaskConfiguration('provideItem', 'one') // Same as ->proivdeItem($state['one']), but runs immediately before this task's run() method.
                ->deferTaskConfiguration('provideMessage', 'two')
                ->storeState('final')
            ->run();

        $this->assertTrue($result->wasSuccessful(), $result->getMessage());

        $state = $collection->getState();
        $this->assertEquals('1st', $state['one']);
        $this->assertEquals('1st', $state['item']);
        $this->assertEquals('2nd', $state['final']);
    }

}




Issues (569)

Security Analysis not enabled

tests/integration/CollectionTest.php (24 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

consolidation / robo

Issues (569)

Security Analysis not enabled

tests/integration/CollectionTest.php (24 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like