vfsStreamWrapperRecordingProxy.php in Zircon Profile 8.0

Namespace

org\bovigo\vfs

File

vendor/mikey179/vfsStream/src/test/php/org/bovigo/vfs/proxy/vfsStreamWrapperRecordingProxy.php

<?php

/**
 * This file is part of vfsStream.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @package  org\bovigo\vfs
 */
namespace org\bovigo\vfs;


/**
 * Stream wrapper to mock file system requests.
 *
 * @since  0.10.0
 */
class vfsStreamWrapperRecordingProxy extends vfsStreamWrapper {

  /**
   * list of called methods for a stream
   *
   * @var  array
   */
  protected static $calledMethods = array();

  /**
   * currently opened path
   *
   * @var  string
   */
  protected $path;

  /**
   * records method call for given path
   *
   * @param  string  $method
   * @param  string  $path
   */
  protected static function recordMethodCall($method, $path) {
    if (isset(self::$calledMethods[$path]) === false) {
      self::$calledMethods[$path] = array();
    }
    self::$calledMethods[$path][] = $method;
  }

  /**
   * returns recorded method calls for given path
   *
   * @param   string         $path
   * @return  array<string>
   */
  public static function getMethodCalls($path) {
    if (isset(self::$calledMethods[$path]) === true) {
      return self::$calledMethods[$path];
    }
    return array();
  }

  /**
   * helper method for setting up vfsStream with the proxy
   *
   * @param   string              $rootDirName  optional  name of root directory
   * @param   int                 $permissions  optional  file permissions of root directory
   * @return  vfsStreamDirectory
   * @throws  vfsStreamException
   */
  public static function setup($rootDirName = 'root', $permissions = null) {
    self::$root = vfsStream::newDirectory($rootDirName, $permissions);
    if (true === self::$registered) {
      return self::$root;
    }
    if (@stream_wrapper_register(vfsStream::SCHEME, __CLASS__) === false) {
      throw new vfsStreamException('A handler has already been registered for the ' . vfsStream::SCHEME . ' protocol.');
    }
    self::$registered = true;
    return self::$root;
  }

  /**
   * open the stream
   *
   * @param   string  $path         the path to open
   * @param   string  $mode         mode for opening
   * @param   string  $options      options for opening
   * @param   string  $opened_path  full path that was actually opened
   * @return  bool
   */
  public function stream_open($path, $mode, $options, $opened_path) {
    $this->path = $path;
    self::recordMethodCall('stream_open', $this->path);
    return parent::stream_open($path, $mode, $options, $opened_path);
  }

  /**
   * closes the stream
   */
  public function stream_close() {
    self::recordMethodCall('stream_close', $this->path);
    return parent::stream_close();
  }

  /**
   * read the stream up to $count bytes
   *
   * @param   int     $count  amount of bytes to read
   * @return  string
   */
  public function stream_read($count) {
    self::recordMethodCall('stream_read', $this->path);
    return parent::stream_read($count);
  }

  /**
   * writes data into the stream
   *
   * @param   string  $data
   * @return  int     amount of bytes written
   */
  public function stream_write($data) {
    self::recordMethodCall('stream_write', $this->path);
    return parent::stream_write($data);
  }

  /**
   * checks whether stream is at end of file
   *
   * @return  bool
   */
  public function stream_eof() {
    self::recordMethodCall('stream_eof', $this->path);
    return parent::stream_eof();
  }

  /**
   * returns the current position of the stream
   *
   * @return  int
   */
  public function stream_tell() {
    self::recordMethodCall('stream_tell', $this->path);
    return parent::stream_tell();
  }

  /**
   * seeks to the given offset
   *
   * @param   int   $offset
   * @param   int   $whence
   * @return  bool
   */
  public function stream_seek($offset, $whence) {
    self::recordMethodCall('stream_seek', $this->path);
    return parent::stream_seek($offset, $whence);
  }

  /**
   * flushes unstored data into storage
   *
   * @return  bool
   */
  public function stream_flush() {
    self::recordMethodCall('stream_flush', $this->path);
    return parent::stream_flush();
  }

  /**
   * returns status of stream
   *
   * @return  array
   */
  public function stream_stat() {
    self::recordMethodCall('stream_stat', $this->path);
    return parent::stream_stat();
  }

  /**
   * retrieve the underlaying resource
   *
   * @param   int  $cast_as
   * @return  bool
   */
  public function stream_cast($cast_as) {
    self::recordMethodCall('stream_cast', $this->path);
    return parent::stream_cast($cast_as);
  }

  /**
   * set lock status for stream
   *
   * @param   int   $operation
   * @return  bool
   */
  public function stream_lock($operation) {
    self::recordMethodCall('stream_link', $this->path);
    return parent::stream_lock($operation);
  }

  /**
   * remove the data under the given path
   *
   * @param   string  $path
   * @return  bool
   */
  public function unlink($path) {
    self::recordMethodCall('unlink', $path);
    return parent::unlink($path);
  }

  /**
   * rename from one path to another
   *
   * @param   string  $path_from
   * @param   string  $path_to
   * @return  bool
   */
  public function rename($path_from, $path_to) {
    self::recordMethodCall('rename', $path_from);
    return parent::rename($path_from, $path_to);
  }

  /**
   * creates a new directory
   *
   * @param   string  $path
   * @param   int     $mode
   * @param   int     $options
   * @return  bool
   */
  public function mkdir($path, $mode, $options) {
    self::recordMethodCall('mkdir', $path);
    return parent::mkdir($path, $mode, $options);
  }

  /**
   * removes a directory
   *
   * @param   string  $path
   * @param   int     $options
   * @return  bool
   */
  public function rmdir($path, $options) {
    self::recordMethodCall('rmdir', $path);
    return parent::rmdir($path, $options);
  }

  /**
   * opens a directory
   *
   * @param   string  $path
   * @param   int     $options
   * @return  bool
   */
  public function dir_opendir($path, $options) {
    $this->path = $path;
    self::recordMethodCall('dir_opendir', $this->path);
    return parent::dir_opendir($path, $options);
  }

  /**
   * reads directory contents
   *
   * @return  string
   */
  public function dir_readdir() {
    self::recordMethodCall('dir_readdir', $this->path);
    return parent::dir_readdir();
  }

  /**
   * reset directory iteration
   *
   * @return  bool
   */
  public function dir_rewinddir() {
    self::recordMethodCall('dir_rewinddir', $this->path);
    return parent::dir_rewinddir();
  }

  /**
   * closes directory
   *
   * @return  bool
   */
  public function dir_closedir() {
    self::recordMethodCall('dir_closedir', $this->path);
    return parent::dir_closedir();
  }

  /**
   * returns status of url
   *
   * @param   string  $path   path of url to return status for
   * @param   int     $flags  flags set by the stream API
   * @return  array
   */
  public function url_stat($path, $flags) {
    self::recordMethodCall('url_stat', $path);
    return parent::url_stat($path, $flags);
  }

}

Classes

Name	Description
vfsStreamWrapperRecordingProxy	Stream wrapper to mock file system requests.