filetransfer.test

<?php


class FileTransferTest extends BackdropWebTestCase {
  protected $hostname = 'localhost';
  protected $username = 'backdrop';
  protected $password = 'password';
  protected $port = '42';

  /**
   * @var TestFileTransfer
   */
  protected $testConnection;

  function setUp() {
    parent::setUp();
    $this->testConnection = TestFileTransfer::factory(BACKDROP_ROOT, array('hostname' => $this->hostname, 'username' => $this->username, 'password' => $this->password, 'port' => $this->port));
  }

  function _getFakeModuleFiles() {
    $files = array(
      'fake.module',
      'fake.info',
      'theme' => array(
        'fake.tpl.php'
      ),
      'inc' => array(
        'fake.inc'
      )
    );
    return $files;
  }

  function _buildFakeModule() {
    $location = 'temporary://fake';
    if (is_dir($location)) {
      $ret = 0;
      $output = array();
      exec('rm -Rf ' . escapeshellarg($location), $output, $ret);
      if ($ret != 0) {
        throw new Exception('Error removing fake module directory.');
      }
    }

    $files = $this->_getFakeModuleFiles();
    $this->_writeDirectory($location, $files);
    return $location;
  }

  function _writeDirectory($base, $files = array()) {
    mkdir($base);
    foreach ($files as $key => $file) {
      if (is_array($file)) {
        $this->_writeDirectory($base . DIRECTORY_SEPARATOR . $key, $file);
      }
      else {
        //just write the filename into the file
        file_put_contents($base . DIRECTORY_SEPARATOR . $file, $file);
      }
    }
  }

  function testJail() {
    $source = $this->_buildFakeModule();

    // This convoluted piece of code is here because our testing framework does
    // not support expecting exceptions.
    $got_it = FALSE;
    try {
      $this->testConnection->copyDirectory($source, '/tmp');
    }
    catch (FileTransferException $e) {
      $got_it = TRUE;
    }
    $this->assertTrue($got_it, 'Was not able to copy a directory outside of the jailed area.');

    $got_it = TRUE;
    try {
      $this->testConnection->copyDirectory($source, BACKDROP_ROOT . '/'. config_get('system.core', 'file_public_path'));
    }
    catch (FileTransferException $e) {
      $got_it = FALSE;
    }
    $this->assertTrue($got_it, 'Was able to copy a directory inside of the jailed area');
  }
}

/**
 * Mock FileTransfer object for test case.
 */
#[\AllowDynamicProperties]
class TestFileTransfer extends FileTransfer {
  protected $host = NULL;
  protected $username = NULL;
  protected $password = NULL;
  protected $port = NULL;

  /**
   * This is for testing the CopyRecursive logic.
   */
  public $shouldIsDirectoryReturnTrue = FALSE;

  function __construct($jail, $username, $password, $hostname = 'localhost', $port = 9999) {
    parent::__construct($jail, $username, $password, $hostname, $port);
  }

  static function factory($jail, $settings) {
    return new TestFileTransfer($jail, $settings['username'], $settings['password'], $settings['hostname'], $settings['port']);
  }

  function connect() {
    $connection = new MockTestConnection();
    $connection->connectionString = 'test://' . urlencode((string) $this->username) . ':' . urlencode((string) $this->password) . "@$this->host:$this->port/";
    $this->connection = $connection;
  }

  function copyFileJailed($source, $destination) {
    $this->connection->run("copyFile $source $destination");
  }

  protected function removeDirectoryJailed($directory) {
    $this->connection->run("rmdir $directory");
  }

  function createDirectoryJailed($directory) {
    $this->connection->run("mkdir $directory");
  }

  function removeFileJailed($destination) {
    if (!ftp_delete($this->connection, $item)) {
      throw new FileTransferException('Unable to remove to file @file.', NULL, array('@file' => $item));
    }
  }

  function isDirectory($path) {
    return $this->shouldIsDirectoryReturnTrue;
  }

  function isFile($path) {
    return FALSE;
  }

  function chmodJailed($path, $mode, $recursive) {
    return;
  }
}

/**
 * Mock connection object for test case.
 */
class MockTestConnection {

  var $commandsRun = array();
  var $connectionString;

  function run($cmd) {
    $this->commandsRun[] = $cmd;
  }

  function flushCommands() {
    $out = $this->commandsRun;
    $this->commandsRun = array();
    return $out;
  }
}