privatebin-mirror/tst/Bootstrap.php

<?php declare(strict_types=1);

use Google\Cloud\Core\Exception\BadRequestException;
use Google\Cloud\Core\Exception\NotFoundException;
use Google\Cloud\Storage\Bucket;
use Google\Cloud\Storage\Connection\ConnectionInterface;
use Google\Cloud\Storage\StorageClient;
use Google\Cloud\Storage\StorageObject;
use PrivateBin\Configuration;
use PrivateBin\Persistence\ServerSalt;
use PrivateBin\TemplateSwitcher;

error_reporting(E_ALL | E_STRICT);

// change this, if your php files and data is outside of your webservers document root
if (!defined('PUBLIC_PATH')) {
    define('PUBLIC_PATH', '..');
}
if (!defined('PATH')) {
    define('PATH', '..' . DIRECTORY_SEPARATOR);
}
if (!defined('CONF')) {
    define('CONF', PATH . 'cfg' . DIRECTORY_SEPARATOR . 'conf.php');
}
if (!defined('CONF_SAMPLE')) {
    define('CONF_SAMPLE', PATH . 'cfg' . DIRECTORY_SEPARATOR . 'conf.sample.php');
}

require PATH . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
TemplateSwitcher::setAvailableTemplates(Configuration::getDefaults()['main']['availabletemplates']);

/**
 * Class Helper provides unit tests pastes and comments of various formats
 */
class Helper
{
    /**
     * example ID of a paste
     *
     * @var string
     */
    private static $pasteid = '5b65a01b43987bc2';

    /**
     * example paste version 2
     *
     * @var array
     */
    private static $pasteV2 = [
        'adata' => [
            [
                'gMSNoLOk4z0RnmsYwXZ8mw==',
                'TZO+JWuIuxs=',
                100000,
                256,
                128,
                'aes',
                'gcm',
                'zlib',
            ],
            'plaintext',
            1,
            0,
        ],
        'meta' => [
            'expire'  => '5min',
        ],
        'v'  => 2,
        'ct' => 'ME5JF/YBEijp2uYMzLZozbKtWc5wfy6R59NBb7SmRig=',
    ];

    /**
     * example ID of a comment
     *
     * @var string
     */
    private static $commentid = '33a5671d11b29d01';

    /**
     * example comment cipher text, its hash is the comment ID
     *
     * @var string
     */
    private static $commentCt = 'XNE9E3AGszrjQfV5bxxSuaflS05MViI3rYtG1Nph0Qc=';

    /**
     * example comment meta data
     *
     * @var array
     */
    private static $commentV2 = [
        'icon'    => 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGUlEQVQokWOsl5/94983CNKQMjnxaOePf98MeKwPfNjkLZ3AgARab6b9+PeNEVnDj3/ff/z7ZiHnzsDA8Pv7H2TVPJw8EAYLAwb48OaVgIgYKycLsrYv378wMDB8//qdCVMDRA9EKSsnCwRBxNsepaLboMFlyMDAICAi9uHNK24GITQ/MDAwoNhgIGMLtwGrzegaLjw5jMz9+vUdnN17uwDCQDhJgk0O07yvX9+teDX1x79v6DYIsIjgcgMaYGFgYOBg4kJx2JejkAiBxAw+PzAwMNz4dp6wDXDw4MdNNOl0rWYsNkD89OLXI/xmo9sgzatJjAYmBgYGDiauD3/ePP18nVgb4MF89+M5ZX6js293wUMpnr8KTQMAxsCJnJ30apMAAAAASUVORK5CYII=',
        'created' => 1344803528,
    ];

    /**
     * get example paste ID
     *
     * @return string
     */
    public static function getPasteId(): string
    {
        return self::$pasteid;
    }

    /**
     * get example paste, as stored on server
     *
     * @param  array $meta
     * @return array
     */
    public static function getPaste(array $meta = []): array
    {
        $example = self::$pasteV2;
        $example['meta']['salt'] = ServerSalt::generate();
        $example['meta'] = array_merge($example['meta'], $meta);
        return $example;
    }

    /**
     * get example paste, as decoded from POST by the request object
     *
     * @param  array $meta
     * @return array
     */
    public static function getPastePost(array $meta = []): array
    {
        $example = self::getPaste($meta);
        $example['meta'] = ['expire' => $example['meta']['expire']];
        return $example;
    }

    /**
     * get example paste, as received via POST by the user
     *
     * @param  array $meta
     * @return string
     */
    public static function getPasteJson(array $meta = []): string
    {
        return json_encode(self::getPastePost($meta));
    }

    /**
     * get example paste ID
     *
     * @return string
     */
    public static function getCommentId(): string
    {
        return self::$commentid;
    }

    /**
     * get example comment, as stored on server
     *
     * @param  array $meta
     * @return array
     */
    public static function getComment(array $meta = []): array
    {
        $example = self::$pasteV2;
        $example['adata'] = $example['adata'][0];
        $example['ct'] = self::$commentCt;
        $example['pasteid'] = $example['parentid'] = self::getPasteId();
        unset($example['meta']['expire']);
        $example['meta'] = array_merge($example['meta'], self::$commentV2);
        $example['meta'] = array_merge($example['meta'], $meta);
        return $example;
    }

    /**
     * get example comment, as decoded from POST by the request object
     *
     * @return array
     */
    public static function getCommentPost(): array
    {
        $example = self::getComment();
        unset($example['meta']);
        return $example;
    }

    /**
     * get example comment, as received via POST by user
     *
     * @return string
     */
    public static function getCommentJson(): string
    {
        return json_encode(self::getCommentPost());
    }

    /**
     * Returns 16 random hexadecimal characters.
     *
     * @return string
     */
    public static function getRandomId(): string
    {
        // 8 binary bytes are 16 characters long in hex
        return bin2hex(random_bytes(8));
    }

    /**
     * delete directory and all its contents recursively
     *
     * @param string $path
     * @throws Exception
     * @return void
     */
    public static function rmDir($path): void
    {
        if (is_dir($path)) {
            foreach (new DirectoryIterator($path) as $file) {
                if ($file->isFile()) {
                    if (!unlink($file->getPathname())) {
                        throw new Exception('Error deleting file "' . $file->getPathname() . '".');
                    }
                } elseif ($file->isDir() && !$file->isDot()) {
                    self::rmDir($file->getPathname());
                }
            }
            if (!rmdir($path)) {
                throw new Exception('Error deleting directory "' . $path . '".');
            }
        }
    }

    /**
     * create a backup of the config file
     *
     * @return void
     */
    public static function confBackup(): void
    {
        if (!is_file(CONF . '.bak') && is_file(CONF)) {
            rename(CONF, CONF . '.bak');
        }
        if (!is_file(CONF_SAMPLE . '.bak') && is_file(CONF_SAMPLE)) {
            copy(CONF_SAMPLE, CONF_SAMPLE . '.bak');
        }
    }

    /**
     * restore backup of the config file
     *
     * @return void
     */
    public static function confRestore(): void
    {
        if (is_file(CONF . '.bak')) {
            rename(CONF . '.bak', CONF);
        }
        if (is_file(CONF_SAMPLE . '.bak')) {
            rename(CONF_SAMPLE . '.bak', CONF_SAMPLE);
        }
    }

    /**
     * create ini file
     *
     * @param string $pathToFile
     * @param array $values
     */
    public static function createIniFile($pathToFile, array $values): void
    {
        if (count($values)) {
            @unlink($pathToFile);
            $ini = fopen($pathToFile, 'a');
            foreach ($values as $section => $options) {
                fwrite($ini, "[$section]" . PHP_EOL);
                foreach ($options as $option => $setting) {
                    if (is_null($setting)) {
                        continue;
                    } elseif (is_string($setting)) {
                        $setting = '"' . $setting . '"';
                    } elseif (is_array($setting)) {
                        foreach ($setting as $key => $value) {
                            if (is_null($value)) {
                                $value = 'null';
                            } elseif (is_string($value)) {
                                $value = '"' . $value . '"';
                            } else {
                                $value = var_export($value, true);
                            }
                            fwrite($ini, $option . "[$key] = $value" . PHP_EOL);
                        }
                        continue;
                    } else {
                        $setting = var_export($setting, true);
                    }
                    fwrite($ini, "$option = $setting" . PHP_EOL);
                }
                fwrite($ini, PHP_EOL);
            }
            fclose($ini);
        }
    }

    /**
     * create a temporary file, returns it's file name
     *
     * @return string
     */
    public static function createTempFile(): string
    {
        return tempnam(sys_get_temp_dir(), 'FOO');
    }

    /**
     * a var_export that returns arrays without line breaks
     * by linus@flowingcreativity.net via php.net
     *
     * @param mixed $var
     * @param bool $return
     * @return void|string
     */
    public static function varExportMin($var, $return = false): string
    {
        if (is_array($var)) {
            $toImplode = [];
            foreach ($var as $key => $value) {
                $toImplode[] = var_export($key, true) . ' => ' . self::varExportMin($value, true);
            }
            $code = 'array(' . implode(', ', $toImplode) . ')';
            if ($return) {
                return $code;
            } else {
                echo $code;
            }
        } else {
            return var_export($var, $return);
        }
    }
}

/**
 * Class BucketStub stubs a GCS bucket.
 */
class BucketStub extends Bucket
{
    public $_objects;
    private $_name;
    private $_info;
    private $_connection;
    private $_client;

    public function __construct(ConnectionInterface $connection, $name, array $info = [], $client = null)
    {
        $this->_name = $name;
        $this->_info = $info;
        $this->_connection = $connection;
        $this->_objects = [];
        $this->_client = $client;
    }

    public function acl()
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function defaultAcl()
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function exists(array $options = [])
    {
        return true;
    }

    public function upload($data, array $options = [])
    {
        if (!is_string($data) || !array_key_exists('name', $options)) {
            throw new BadMethodCallException('not supported by this stub');
        }

        $name = $options['name'];
        $generation = '1';
        $o = new StorageObjectStub($this->_connection, $name, $this, $generation, $options);
        $this->_objects[$options['name']] = $o;
        $o->setData($data);
    }

    public function uploadAsync($data, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getResumableUploader($data, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getStreamableUploader($data, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function object($name, array $options = [])
    {
        return $this->_objects[$name] ?? new StorageObjectStub($this->_connection, $name, $this, null, $options);
    }

    public function objects(array $options = [])
    {
        $prefix = $options['prefix'] ?? '';

        return new CallbackFilterIterator(
            new ArrayIterator($this->_objects),
            function ($current, $key, $iterator) use ($prefix) {
                return substr($key, 0, strlen($prefix)) === $prefix;
            }
        );
    }

    public function createNotification($topic, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function notification($id)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function notifications(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function delete(array $options = [])
    {
        $this->_client->deleteBucket($this->_name);
    }

    public function update(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function compose(array $sourceObjects, $name, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function info(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function reload(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function name()
    {
        return $this->_name;
    }

    public static function lifecycle(array $lifecycle = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function currentLifecycle(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function isWritable($file = null)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function iam()
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function lockRetentionPolicy(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function signedUrl($expires, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function generateSignedPostPolicyV4($objectName, $expires, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }
}

/**
 * Class StorageObjectStub stubs a GCS storage object.
 */
class StorageObjectStub extends StorageObject
{
    private $_name;
    private $_data;
    private $_info;
    private $_bucket;
    private $_generation;
    private $_exists = false;
    private $_connection;

    public function __construct(ConnectionInterface $connection, $name, $bucket, $generation = null, array $info = [], $encryptionKey = null, $encryptionKeySHA256 = null)
    {
        $this->_name = $name;
        $this->_bucket = $bucket;
        $this->_generation = $generation;
        $this->_info = $info;
        $this->_connection = $connection;
        $timeCreated = new DateTime();
        $this->_info['metadata']['timeCreated'] = $timeCreated->format('Y-m-d\TH:i:s.u\Z');
    }

    public function acl()
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function exists(array $options = [])
    {
        return array_key_exists($this->_name, $this->_bucket->_objects);
    }

    /**
     * @throws NotFoundException
     */
    public function delete(array $options = [])
    {
        if (array_key_exists($this->_name, $this->_bucket->_objects)) {
            unset($this->_bucket->_objects[$this->_name]);
        } else {
            throw new NotFoundException('key ' . $this->_name . ' not found.');
        }
    }

    /**
     * @throws NotFoundException
     */
    public function update(array $metadata, array $options = [])
    {
        if (!$this->_exists) {
            throw new NotFoundException('key ' . $this->_name . ' not found.');
        }
        $this->_info = $metadata;
    }

    public function copy($destination, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function rewrite($destination, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function rename($name, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    /**
     * @throws NotFoundException
     */
    public function downloadAsString(array $options = [])
    {
        if (!$this->_exists) {
            throw new NotFoundException('key ' . $this->_name . ' not found.');
        }
        return $this->_data;
    }

    public function downloadToFile($path, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function downloadAsStream(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function downloadAsStreamAsync(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function signedUrl($expires, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function signedUploadUrl($expires, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function beginSignedUploadSession(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function info(array $options = [])
    {
        return $this->_info['metadata'] ?? [];
    }

    public function reload(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function name()
    {
        return $this->_name;
    }

    public function identity()
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function gcsUri()
    {
        return sprintf(
            'gs://%s/%s',
            $this->_bucket->name(),
            $this->_name
        );
    }

    public function setData($data)
    {
        $this->_data = $data;
        $this->_exists = true;
    }
}

/**
 * Class ConnectionInterfaceStub required for the stubs.
 */
class ConnectionInterfaceStub implements ConnectionInterface
{
    public function deleteAcl(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getAcl(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function listAcl(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function insertAcl(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function patchAcl(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function deleteBucket(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function restoreBucket(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getBucket(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function listBuckets(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function insertBucket(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getBucketIamPolicy(array $args)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function setBucketIamPolicy(array $args)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function testBucketIamPermissions(array $args)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function patchBucket(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function deleteObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function restoreObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function copyObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function rewriteObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function moveObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function composeObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function headObject(array $args = []): array
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function listObjects(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function patchObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function downloadObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function insertObject(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getNotification(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function deleteNotification(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function insertNotification(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function listNotifications(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getServiceAccount(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function lockRetentionPolicy(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function createHmacKey(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function deleteHmacKey(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getHmacKey(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function updateHmacKey(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function listHmacKeys(array $args = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }
}

/**
 * Class StorageClientStub provides a limited stub for performing the unit test
 */
class StorageClientStub extends StorageClient
{
    private $_config = null;
    private $_connection = null;
    private static $_buckets = [];

    public function __construct(array $config = [])
    {
        $this->_config = $config;
        $this->_connection = new ConnectionInterfaceStub();
    }

    public function bucket($name, $userProject = false, array $config = [])
    {
        if (!array_key_exists($name, self::$_buckets)) {
            self::$_buckets[$name] = new BucketStub($this->_connection, $name, [], $this);
        }
        return self::$_buckets[$name];
    }

    /**
     * @throws \Google\Cloud\Core\Exception\NotFoundException
     */
    public function deleteBucket($name)
    {
        if (array_key_exists($name, self::$_buckets)) {
            unset(self::$_buckets[$name]);
        } else {
            throw new NotFoundException();
        }
    }

    public function buckets(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function registerStreamWrapper($protocol = null)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function unregisterStreamWrapper($protocol = null)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function signedUrlUploader($uri, $data, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function timestamp(\DateTimeInterface $timestamp, $nanoSeconds = null)
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function getServiceAccount(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function hmacKeys(array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function hmacKey($accessId, $projectId = null, array $metadata = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function createHmacKey($serviceAccountEmail, array $options = [])
    {
        throw new BadMethodCallException('not supported by this stub');
    }

    public function createBucket($name, array $options = [])
    {
        if (array_key_exists($name, self::$_buckets)) {
            throw new BadRequestException('already exists');
        }
        $b = new BucketStub($this->_connection, $name, [], $this);
        self::$_buckets[$name] = $b;
        return $b;
    }
}