composer/tests/Composer/Test/Util/PerforceTest.php

<?php
/*
 * This file is part of Composer.
 *
 * (c) Nils Adermann <naderman@naderman.de>
 *     Jordi Boggiano <j.boggiano@seld.be>
 *
 *  Contributor: Matt Whittom <Matt.Whittom@veteransunited.com>
 *  Date: 7/17/13
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */


namespace Composer\Test\Util;

use Composer\Util\Perforce;
use Composer\Util\ProcessExecutor;

/**
 * @author Matt Whittom <Matt.Whittom@veteransunited.com>
 */
class PerforceTest extends \PHPUnit_Framework_TestCase {

    protected $perforce;
    protected $processExecutor;

    public function setUp() {
        $this->processExecutor = $this->getMock('Composer\Util\ProcessExecutor');
        $repoConfig = array("depot"=>"depot", "branch"=>"branch", "p4user"=>"user");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, true, "TEST");
    }

    public function testGetClientWithoutStream() {
        $client = $this->perforce->getClient();
        $hostname = gethostname();
        $timestamp = time();

        $expected = "composer_perforce_TEST_depot";
        $this->assertEquals($expected, $client);
    }

    public function testGetClientFromStream() {
        $this->setPerforceToStream();

        $client = $this->perforce->getClient();

        $expected = "composer_perforce_TEST_depot_branch";
        $this->assertEquals($expected, $client);
    }

    public function testGetStreamWithoutStream() {
        $stream = $this->perforce->getStream();
        $this->assertEquals("//depot", $stream);
    }

    public function testGetStreamWithStream() {
        $this->setPerforceToStream();

        $stream = $this->perforce->getStream();
        $this->assertEquals("//depot/branch", $stream);
    }


    public function testGetStreamWithoutLabelWithStreamWithoutLabel(){
        $stream = $this->perforce->getStreamWithoutLabel("//depot/branch");
        $this->assertEquals("//depot/branch", $stream);
    }

    public function testGetStreamWithoutLabelWithStreamWithLabel(){
        $stream = $this->perforce->getStreamWithoutLabel("//depot/branching@label");
        $this->assertEquals("//depot/branching", $stream);
    }

    public function testGetClientSpec() {
        $clientSpec = $this->perforce->getP4ClientSpec();
        $expected = "path/composer_perforce_TEST_depot.p4.spec";
        $this->assertEquals($expected, $clientSpec);
    }

    public function testGenerateP4Command() {
        $command = "do something";
        $p4Command = $this->perforce->generateP4Command($command);
        $expected = "p4 -u user -c composer_perforce_TEST_depot -p port do something";
        $this->assertEquals($expected, $p4Command);
    }

    public function testQueryP4UserWithUserAlreadySet(){
        $io = $this->getMock('Composer\IO\IOInterface');

        $repoConfig = array("depot"=>"depot", "branch"=>"branch", "p4user"=>"TEST_USER");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, true, "TEST");

        $this->perforce->queryP4user($io);
        $this->assertEquals("TEST_USER", $this->perforce->getUser());
    }

    public function testQueryP4UserWithUserSetInP4VariablesWithWindowsOS(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, true, "TEST");

        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedCommand = "p4 set";
        $this->processExecutor->expects($this->at(0))
            ->method('execute')
            ->with($this->equalTo($expectedCommand))
            ->will($this->returnCallback(function($command, &$output) {$output =  "P4USER=TEST_P4VARIABLE_USER\n"; return true;}));

        $this->perforce->queryP4user($io);
        $this->assertEquals("TEST_P4VARIABLE_USER", $this->perforce->getUser());
    }

    public function testQueryP4UserWithUserSetInP4VariablesNotWindowsOS(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, false, "TEST");

        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedCommand = 'echo $P4USER';
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "TEST_P4VARIABLE_USER\n"; return true;}));

        $this->perforce->queryP4user($io);
        $this->assertEquals("TEST_P4VARIABLE_USER", $this->perforce->getUser());
    }

    public function testQueryP4UserQueriesForUser(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, false, "TEST");
        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedQuestion = "Enter P4 User:";
        $io->expects($this->at(0))
            ->method('ask')
            ->with($this->equalTo($expectedQuestion))
            ->will($this->returnValue("TEST_QUERY_USER"));

        $this->perforce->queryP4user($io);
        $this->assertEquals("TEST_QUERY_USER", $this->perforce->getUser());
    }

    public function testQueryP4UserStoresResponseToQueryForUserWithWindows(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, true, "TEST");

        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedQuestion = "Enter P4 User:";
        $io->expects($this->at(0))
            ->method('ask')
            ->with($this->equalTo($expectedQuestion))
            ->will($this->returnValue("TEST_QUERY_USER"));
        $expectedCommand = "p4 set P4USER=TEST_QUERY_USER";
        $this->processExecutor->expects($this->at(1))
            ->method('execute')
            ->with($this->equalTo($expectedCommand))
            ->will($this->returnValue(0));

        $this->perforce->queryP4user($io);
    }

    public function testQueryP4UserStoresResponseToQueryForUserWithoutWindows(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, false, "TEST");

        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedQuestion = "Enter P4 User:";
        $io->expects($this->at(0))
        ->method('ask')
        ->with($this->equalTo($expectedQuestion))
        ->will($this->returnValue("TEST_QUERY_USER"));
        $expectedCommand = "export P4USER=TEST_QUERY_USER";
        $this->processExecutor->expects($this->at(1))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnValue(0));

        $this->perforce->queryP4user($io);
    }

    public function testQueryP4PasswordWithPasswordAlreadySet(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch", "p4user"=>"user", "p4password"=>"TEST_PASSWORD");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, false, "TEST");
        $io = $this->getMock('Composer\IO\IOInterface');

        $password = $this->perforce->queryP4Password($io);
        $this->assertEquals("TEST_PASSWORD", $password);
    }

    public function testQueryP4PasswordWithPasswordSetInP4VariablesWithWindowsOS(){
        $io = $this->getMock('Composer\IO\IOInterface');

        $expectedCommand = "p4 set";
        $this->processExecutor->expects($this->at(0))
            ->method('execute')
            ->with($this->equalTo($expectedCommand))
            ->will($this->returnCallback(function($command, &$output) {$output =  "P4PASSWD=TEST_P4VARIABLE_PASSWORD\n"; return true;}));

        $password = $this->perforce->queryP4Password($io);
        $this->assertEquals("TEST_P4VARIABLE_PASSWORD", $password);
    }

    public function testQueryP4PasswordWithPasswordSetInP4VariablesNotWindowsOS(){
        $repoConfig = array("depot"=>"depot", "branch"=>"branch", "p4user"=>"user");
        $this->perforce = new Perforce($repoConfig, "port", "path", $this->processExecutor, false, "TEST");

        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedCommand = 'echo $P4PASSWD';
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "TEST_P4VARIABLE_PASSWORD\n"; return true;}));

        $password = $this->perforce->queryP4Password($io);
        $this->assertEquals("TEST_P4VARIABLE_PASSWORD", $password);
    }

    public function testQueryP4PasswordQueriesForPassword(){
        $io = $this->getMock('Composer\IO\IOInterface');
        $expectedQuestion = "Enter password for Perforce user user: ";
        $io->expects($this->at(0))
            ->method('askAndHideAnswer')
            ->with($this->equalTo($expectedQuestion))
            ->will($this->returnValue("TEST_QUERY_PASSWORD"));

        $password = $this->perforce->queryP4Password($io);
        $this->assertEquals("TEST_QUERY_PASSWORD", $password);
    }

    public function testWriteP4ClientSpecWithoutStream() {
        $stream = fopen("php://memory", 'w+');
        $this->perforce->writeClientSpecToFile($stream);

        rewind($stream);
        $expectedArray = $this->getExpectedClientSpec(FALSE);
        try {
            foreach ($expectedArray as $expected) {
                $this->assertStringStartsWith($expected, fgets($stream));
            }
            $this->assertFalse(fgets($stream));
        } catch (Exception $e) {
            fclose($stream);
            throw $e;
        }
        fclose($stream);
    }

    public function testWriteP4ClientSpecWithStream() {
        $this->setPerforceToStream();
        $stream = fopen("php://memory", 'w+');

        $this->perforce->writeClientSpecToFile($stream);
        rewind($stream);

        $expectedArray = $this->getExpectedClientSpec(TRUE);
        try {
            foreach ($expectedArray as $expected) {
                $this->assertStringStartsWith($expected, fgets($stream));
            }
            $this->assertFalse(fgets($stream));
        } catch (Exception $e) {
            fclose($stream);
            throw $e;
        }
        fclose($stream);
    }

    public function testIsLoggedIn() {
        $expectedCommand = "p4 -u user -p port login -s";
        $this->processExecutor->expects($this->at(0))
            ->method('execute')
            ->with($this->equalTo($expectedCommand), $this->equalTo(null))
            ->will($this->returnValue(0));

        $this->perforce->isLoggedIn();
    }

    public function testConnectClient() {
        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot -p port client -i < path/composer_perforce_TEST_depot.p4.spec";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand), $this->equalTo(null))
        ->will($this->returnValue(0));

        $this->perforce->connectClient();
    }

    public function testGetBranchesWithStream() {
        $this->setPerforceToStream();

        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot_branch -p port streams //depot/...";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "Stream //depot/branch mainline none 'branch'\n"; return true;}));

        $branches = $this->perforce->getBranches();
        $this->assertEquals("//depot/branch", $branches['master']);
    }

    public function testGetBranchesWithoutStream() {
        $branches = $this->perforce->getBranches();
        $this->assertEquals("//depot", $branches['master']);
    }

    public function testGetTagsWithoutStream() {
        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot -p port labels";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "Label 0.0.1 2013/07/31 'First Label!'\nLabel 0.0.2 2013/08/01 'Second Label!'\n"; return true;}));

        $tags = $this->perforce->getTags();
        $this->assertEquals("//depot@0.0.1", $tags['0.0.1']);
        $this->assertEquals("//depot@0.0.2", $tags['0.0.2']);
    }

    public function testGetTagsWithStream() {
        $this->setPerforceToStream();

        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot_branch -p port labels";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "Label 0.0.1 2013/07/31 'First Label!'\nLabel 0.0.2 2013/08/01 'Second Label!'\n"; return true;}));

        $tags = $this->perforce->getTags();
        $this->assertEquals("//depot/branch@0.0.1", $tags['0.0.1']);
        $this->assertEquals("//depot/branch@0.0.2", $tags['0.0.2']);
    }

    public function testCheckStreamWithoutStream() {
        $result = $this->perforce->checkStream("depot");
        $this->assertFalse($result);
        $this->assertFalse($this->perforce->isStream());
    }

    public function testCheckStreamWithStream() {
        $this->processExecutor->expects($this->any())->method('execute')
        ->will($this->returnCallback(function($command, &$output) {$output =  "Depot depot 2013/06/25 stream /p4/1/depots/depot/... 'Created by Me'"; return true;}));
        $result = $this->perforce->checkStream("depot");
        $this->assertTrue($result);
        $this->assertTrue($this->perforce->isStream());
    }

    public function testGetComposerInformationWithoutLabelWithoutStream() {
        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot -p port  print //depot/composer.json";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  PerforceTest::getComposerJson(); return true;}));

        $result = $this->perforce->getComposerInformation("//depot");
        $expected = array(
            "name"              => "test/perforce",
            "description"       => "Basic project for testing",
            "minimum-stability" => "dev",
            "autoload"          => array("psr-0" => array())
        );
        $this->assertEquals($expected, $result);
    }

    public function testGetComposerInformationWithLabelWithoutStream() {
        $expectedCommand = "p4 -u user -p port  files //depot/composer.json@0.0.1";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "//depot/composer.json#1 - branch change 10001 (text)"; return true;}));

        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot -p port  print //depot/composer.json@10001";
        $this->processExecutor->expects($this->at(1))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  PerforceTest::getComposerJson(); return true;}));

        $result = $this->perforce->getComposerInformation("//depot@0.0.1");

        $expected = array(
            "name"              => "test/perforce",
            "description"       => "Basic project for testing",
            "minimum-stability" => "dev",
            "autoload"          => array("psr-0" => array())
        );
        $this->assertEquals($expected, $result);
    }

    public function testGetComposerInformationWithoutLabelWithStream() {
        $this->setPerforceToStream();

        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot_branch -p port  print //depot/branch/composer.json";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  PerforceTest::getComposerJson(); return true;}));

        $result = $this->perforce->getComposerInformation("//depot/branch");

        $expected = array(
            "name"              => "test/perforce",
            "description"       => "Basic project for testing",
            "minimum-stability" => "dev",
            "autoload"          => array("psr-0" => array())
        );
        $this->assertEquals($expected, $result);
    }

    public function testGetComposerInformationWithLabelWithStream() {
        $this->setPerforceToStream();
        $expectedCommand = "p4 -u user -p port  files //depot/branch/composer.json@0.0.1";
        $this->processExecutor->expects($this->at(0))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  "//depot/composer.json#1 - branch change 10001 (text)"; return true;}));

        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot_branch -p port  print //depot/branch/composer.json@10001";
        $this->processExecutor->expects($this->at(1))
        ->method('execute')
        ->with($this->equalTo($expectedCommand))
        ->will($this->returnCallback(function($command, &$output) {$output =  PerforceTest::getComposerJson(); return true;}));

        $result = $this->perforce->getComposerInformation("//depot/branch@0.0.1");

        $expected = array(
            "name"              => "test/perforce",
            "description"       => "Basic project for testing",
            "minimum-stability" => "dev",
            "autoload"          => array("psr-0" => array())
        );
        $this->assertEquals($expected, $result);
    }

    public function testSyncCodeBaseWithoutStream() {
        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot -p port sync -f @label";
        $this->processExecutor->expects($this->at(1))
        ->method('execute')
        ->with($this->equalTo($expectedCommand), $this->equalTo(null))
        ->will($this->returnValue(0));

        $this->perforce->syncCodeBase("label");
    }

    public function testSyncCodeBaseWithStream() {
        $this->setPerforceToStream();
        $expectedCommand = "p4 -u user -c composer_perforce_TEST_depot_branch -p port sync -f @label";
            $this->processExecutor->expects($this->at(1))
            ->method('execute')
            ->with($this->equalTo($expectedCommand))
            ->will($this->returnValue(0));

        $this->perforce->syncCodeBase("label");
    }

    public function testCheckServerExists() {
        $processExecutor = $this->getMock('Composer\Util\ProcessExecutor');

        $expectedCommand = "p4 -p perforce.does.exist:port info -s";
        $processExecutor->expects($this->at(0))
            ->method('execute')
            ->with($this->equalTo($expectedCommand), $this->equalTo(null))
            ->will($this->returnValue(0));

        $result = $this->perforce->checkServerExists("perforce.does.exist:port", $processExecutor);
        $this->assertTrue($result);
    }

    public function testCheckServerExistsWithFailure() {
        $processExecutor = $this->getMock('Composer\Util\ProcessExecutor');

        $expectedCommand = "p4 -p perforce.does.not.exist:port info -s";
        $processExecutor->expects($this->at(0))
            ->method('execute')
            ->with($this->equalTo($expectedCommand), $this->equalTo(null))
            ->will($this->returnValue("Perforce client error:"));

        $result = $this->perforce->checkServerExists("perforce.does.not.exist:port", $processExecutor);
        $this->assertTrue($result);
    }

    public static function getComposerJson() {
        $composer_json = array(
            '{',
            '"name": "test/perforce",',
            '"description": "Basic project for testing",',
            '"minimum-stability": "dev",',
            '"autoload": {',
            '"psr-0" : {',
            '}',
            '}',
            '}'
        );

        return implode($composer_json);
    }

    private function getExpectedClientSpec($withStream) {
        $expectedArray = array(
            "Client: composer_perforce_TEST_depot",
            "\n",
            "Update:",
            "\n",
            "Access:",
            "Owner:  user",
            "\n",
            "Description:",
            "  Created by user from composer.",
            "\n",
            "Root: path",
            "\n",
            "Options:  noallwrite noclobber nocompress unlocked modtime rmdir",
            "\n",
            "SubmitOptions:  revertunchanged",
            "\n",
            "LineEnd:  local",
            "\n"
        );
        if ($withStream) {
            $expectedArray[] = "Stream:";
            $expectedArray[] = "  //depot/branch";
        }
        else {
            $expectedArray[] = "View:  //depot/...  //composer_perforce_TEST_depot/depot/...";
        }

        return $expectedArray;
    }

    private function setPerforceToStream(){
        $this->perforce->setStream("//depot/branch");
    }
}