Beispiel #1
0
 /**
  * Runs the error controller action for the specified HTTP error code.
  *
  * @param int $errorCode   The error code
  *
  * @return void
  */
 protected function runErrorAction($errorCode)
 {
     $controllerName = $this->config->get('system.errorController', self::DEFAULT_ERROR_CONTROLLER_NAME);
     try {
         try {
             $controller = $this->diContainer->getController($controllerName, $this->request, $this->response);
         } catch (ControllerException $exception) {
             // No such controller, fall back to built in default
             $controller = $this->diContainer->getDefaultErrorController($this->request, $this->response);
             $controllerName = self::DEFAULT_ERROR_CONTROLLER_NAME;
         }
     } catch (\Exception $e) {
         $this->dispatchedController = $controllerName;
         $this->dispatchedAction = 500;
         throw $e;
     }
     $this->dispatchedController = $controllerName;
     $this->dispatchedAction = $errorCode;
     $this->raiseEventIfNotRaisedYet(Event::TYPE_APPLICATION_BEFORE_CONTROLLER_RUN);
     $controller->run($errorCode);
     $this->raiseEventIfNotRaisedYet(Event::TYPE_APPLICATION_AFTER_CONTROLLER_RUN);
     $this->response->render();
     $this->raiseEventIfNotRaisedYet(Event::TYPE_APPLICATION_BEFORE_OUTPUT_SEND);
     $this->response->send();
     $this->raiseEventIfNotRaisedYet(Event::TYPE_APPLICATION_AFTER_OUTPUT_SEND);
 }
Beispiel #2
0
 /**
  * Constructor.
  *
  * @param string $keyPrefix   The prefix for the cache keys of the bo instance. If not set, one will be generated
  *                            based on the configuration and the class-name.
  */
 public function __construct($keyPrefix = null)
 {
     if (empty($keyPrefix)) {
         $keyPrefix = Config::getInstance()->get('system.project.name') . '.' . get_class($this);
     }
     $this->keyPrefix = $keyPrefix;
 }
Beispiel #3
0
 /**
  * Sets up the fixture, for example, open a network connection.
  * This method is called before a test is executed.
  *
  * @return void
  */
 protected function setUp()
 {
     parent::setUp();
     Config::getInstance()->set(array('resource.log.' . self::SYSLOG_CONNECTION_CONFIG_NAME . '.facility' => LOG_LOCAL5, 'resource.log.' . self::SYSLOG_CONNECTION_CONFIG_NAME . '.applicationIdent' => self::SYSLOG_CONNECTION_APPLICATION_INDENT, 'resource.log.' . self::SYSLOG_CONNECTION_CONFIG_NAME . '.includeSapiName' => false, 'resource.log.' . self::SYSLOG_CONNECTION_CONFIG_NAME . '.addPid' => false));
     $this->syslogConnectionMock = new SyslogConnectionMock();
     $this->syslogLogger = new SyslogLoggerMock(self::SYSLOG_CONNECTION_CONFIG_NAME, $this->syslogConnectionMock);
 }
Beispiel #4
0
 /**
  * Creates a syslog connection.
  *
  * @param string                              $configName   The name of the configuration to use.
  * @param \YapepBase\Syslog\ISyslogConnection $connection   The Syslog connection to use.
  *
  * @todo Remove the possibility to set config options. Use only the set connection [emul]
  */
 public function __construct($configName, \YapepBase\Syslog\ISyslogConnection $connection = null)
 {
     $config = Config::getInstance();
     $properties = array('applicationIdent', 'facility', 'includeSapiName', 'addPid');
     foreach ($properties as $property) {
         try {
             $this->configOptions[$property] = $config->get('resource.log.' . $configName . '.' . $property, false);
         } catch (ConfigException $e) {
             // We just swallow this because we don't know what properties do we need in advance
         }
     }
     $this->verifyConfig($configName);
     if ($connection) {
         $this->connection = $connection;
         //@codeCoverageIgnoreStart
     } elseif (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
         $this->connection = new \YapepBase\Syslog\LegacySyslogConnection();
     } else {
         $this->connection = new \YapepBase\Syslog\NativeSyslogConnection();
     }
     //@codeCoverageIgnoreEnd
     $ident = $this->configOptions['applicationIdent'];
     if (isset($this->configOptions['includeSapiName']) && $this->configOptions['includeSapiName']) {
         $ident .= '-' . PHP_SAPI;
     }
     // TODO: Can be dangerous as it can override an already set value [emul]
     $this->connection->setIdent($ident);
     $this->connection->setFacility($this->configOptions['facility']);
     $options = 0;
     if (isset($this->configOptions['addPid']) && $this->configOptions['addPid']) {
         $options += \YapepBase\Syslog\ISyslogConnection::LOG_PID;
     }
     $this->connection->setOptions($options);
     $this->connection->open();
 }
 protected function setUp()
 {
     parent::setUp();
     // TODO Make this setting global. For this, there should be a base class for all tests [szeber]
     Config::getInstance()->set('system.project.name', 'test');
     $this->originalObLevel = ob_get_level();
 }
Beispiel #6
0
 /**
  * Constructor.
  *
  * @param \YapepBase\Request\IRequest      $request         The request instance
  * @param string                           $configName      The name of the configuration where the routes are
  *                                                          stored.
  * @param \YapepBase\Router\IReverseRouter $reverseRouter   The reverse router to use. If not set, it will use
  *                                                          an ArrayReverseRouter.
  *
  * @throws RouterException   On error
  */
 public function __construct(IRequest $request, $configName, IReverseRouter $reverseRouter = null)
 {
     $routes = Config::getInstance()->get('resource.routing.' . $configName, false);
     if (!is_array($routes)) {
         throw new RouterException('No route config found for name: ' . $configName, RouterException::ERR_ROUTE_CONFIG);
     }
     parent::__construct($request, $routes, $reverseRouter);
 }
Beispiel #7
0
 /**
  * Returns the requested storage.
  *
  * @param string $configName   The name of the config.
  *
  * @throws \YapepBase\Exception\StorageException   If the given storage type is invalid.
  * @throws \YapepBase\Exception\ConfigException    On configuration errors.
  *
  * @return \YapepBase\Storage\StorageAbstract
  */
 public static function get($configName)
 {
     if (!isset(static::$storages[$configName])) {
         $config = Config::getInstance();
         $storageType = $config->get('resource.storage.' . $configName . '.storageType');
         if (empty($storageType)) {
             throw new StorageException('No storageType configured in the config: ' . $configName);
         }
         static::$storages[$configName] = static::getStorage($configName, $storageType);
     }
     return static::$storages[$configName];
 }
 /**
  * Runs the action and returns the result as an ViewAbstract instance.
  *
  * @param string $methodName   The name of the method that contains the action.
  *
  * @return string|\YapepBase\View\RestTemplate   The result view or the rendered output.
  *
  * @throws \YapepBase\Exception\ControllerException   On controller specific error. (eg. action not found)
  * @throws \YapepBase\Exception\Exception             On framework related errors.
  * @throws \Exception                                 On non-framework related errors.
  */
 protected function runAction($methodName)
 {
     $result = $this->{$methodName}();
     if (is_array($result)) {
         $view = new RestTemplate();
         $view->setRootNode(Config::getInstance()->get('system.rest.xmlRootNode', 'rest'));
         $view->setContent($result);
         return $view;
     } elseif (!is_string($result) && !$result instanceof RestTemplate) {
         throw new ControllerException('The received result is not a RestTemplate or an array or string', ControllerException::ERR_INVALID_ACTION_RETURN_VALUE);
     }
     return $result;
 }
Beispiel #9
0
 /**
  * Constructor.
  *
  * @param string $configName   The name of the configuration to use.
  *
  * @throws \YapepBase\Exception\ConfigException    On configuration errors.
  * @throws \YapepBase\Exception\StorageException   On storage errors.
  */
 public function __construct($configName)
 {
     $this->currentConfigurationName = $configName;
     $properties = $this->getConfigProperties();
     $configData = array();
     foreach ($properties as $property) {
         try {
             $configData[$property] = Config::getInstance()->get('resource.storage.' . $configName . '.' . $property);
         } catch (ConfigException $e) {
             // We just swallow this because we don't know what properties do we need in advance
         }
     }
     $this->setupConfig($configData);
 }
Beispiel #10
0
 /**
  * Test configuration section handling
  */
 public function testSections()
 {
     $testData = array('test.first' => 1, 'test.second' => 2, 'test.secondLevel.first' => 'first', 'test.secondLevel.second' => 'second', 'test2' => 'test');
     $this->config->set($testData);
     $this->assertSame(false, $this->config->get('test*', false), 'Returning invalid wildcard returns the default');
     $result = $this->config->get('test.*');
     $this->assertInternalType('array', $result);
     $this->assertEquals(4, count($result));
     $this->assertArrayHasKey('first', $result);
     $this->assertSame(1, $result['first']);
     $result = $this->config->get('test.*', null, true);
     $this->assertInternalType('array', $result);
     $this->assertEquals(4, count($result));
     $this->assertArrayHasKey('test.first', $result);
     $this->assertSame(1, $result['test.first']);
 }
 /**
  * Runs the command and returns the command output and the separated STDERR in the outgoing parameter.
  *
  * Uses the "system.commandOutputHelper.work.path" config, what is describes the directory where the temporary
  * file pointer will be added. (default => /tmp)
  *
  * @param CommandExecutor $command   The command executor object.
  * @param string          $stdErr    The error messages [Outgoing]
  *
  * @return \YapepBase\Shell\CommandOutput   The output of the command.
  * @throws \Exception
  */
 public function runCommandWithStdErr(CommandExecutor $command, &$stdErr)
 {
     $dir = Config::getInstance()->get('system.commandOutputHelper.work.path', '/tmp');
     $pipePath = tempnam($dir, 'stderr-');
     $fileHandler = Application::getInstance()->getDiContainer()->getFileHandler();
     try {
         posix_mkfifo($pipePath, 0755);
         $command->setOutputRedirection(CommandExecutor::OUTPUT_REDIRECT_STDERR, $pipePath);
         $result = $command->run();
         $stdErr = $fileHandler->getAsString($pipePath);
         $fileHandler->remove($pipePath);
     } catch (\Exception $e) {
         if ($fileHandler->checkIsPathExists($pipePath)) {
             $fileHandler->remove($pipePath);
         }
         throw $e;
     }
     return $result;
 }
 /**
  * Tests the runCommandWithStdErr() method.
  *
  * @return void
  */
 public function testRunCommandWithStdErr()
 {
     $testPath = getenv('YAPEPBASE_TEST_TEMPPATH');
     $this->testFilePath = null;
     $testInstance = $this;
     $expectedError = 'error message';
     $commandExecutorMock = \Mockery::mock('\\YapepBase\\Shell\\CommandExecutor')->shouldReceive('setOutputRedirection')->with(CommandExecutor::OUTPUT_REDIRECT_STDERR, \Mockery::on(function ($param) use($testInstance) {
         $testInstance->testFilePath = $param;
         return true;
     }))->getMock()->shouldReceive('run')->andReturnUsing(function () use($testInstance, $expectedError) {
         file_put_contents($testInstance->testFilePath, $expectedError);
         return new CommandOutput('test', '', 0, 'test 2> ' . $testInstance->testFilePath);
     })->getMock();
     if (empty($testPath)) {
         $this->markTestSkipped('Test cannot be done without a test directory');
     }
     if (!file_exists($testPath) && !mkdir($testPath, 0755, true)) {
         $this->fail('The test path does not exist, and cannot be created: ' . $testPath);
     }
     Config::getInstance()->set('system.commandOutputHelper.work.path', $testPath);
     $this->commandOutputHelper->runCommandWithStdErr($commandExecutorMock, $errorMessage);
     $this->assertEquals($expectedError, $errorMessage);
     $this->assertFileNotExists($this->testFilePath);
 }
Beispiel #13
0
 public function create($username, $password, $email)
 {
     $passwordHash = password_hash($password, PASSWORD_DEFAULT, ['cost' => Config::getInstance()->get('application.passwordHash.cost')]);
     return $this->getUserDao()->create($username, $passwordHash, $email);
 }
Beispiel #14
0
 /**
  * Outputs (echoes) all parameters.
  *
  * @return void
  */
 public function out()
 {
     if (Config::getInstance()->get('system.output.gzip', false)) {
         ob_start('ob_gzhandler');
     } else {
         ob_start();
     }
     foreach (func_get_args() as $string) {
         echo $string;
     }
     ob_end_flush();
 }
Beispiel #15
0
 /**
  * Tests if the factory produces an error on trying to create a connection to an invalid backend.
  */
 public function testBadConnectionBackendType()
 {
     $this->setExpectedException('\\YapepBase\\Exception\\DatabaseException', 'Invalid database config');
     $this->config->set(array('resource.database.test2.rw.backendType' => 'invalid'));
     DbFactory::getConnection('test2', DbFactory::TYPE_READ_WRITE);
 }
Beispiel #16
0
 protected function setUp()
 {
     parent::setUp();
     $this->originalObLevel = ob_get_level();
     Config::getInstance()->set(array('resource.missingCookieName.namespace' => 'test2'));
 }
Beispiel #17
0
 /**
  * Returns a new OAuth helper instance.
  *
  * @return OAuth
  */
 public function getOAuth()
 {
     $config = Config::getInstance();
     return new OAuth($config->get('resource.vend.oauth.clientId'), $config->get('resource.vend.oauth.clientSecret'), $config->get('resource.vend.oauth.redirectUri'));
 }
Beispiel #18
0
 /**
  * Returns a database connection of the specified name and type
  *
  * @param string $connectionName   The name of the database connection.
  * @param string $connectionType   The type of the database connection. {@uses self::TYPE_*}
  *
  * @return DbConnectionAbstract   The requested connection.
  *
  * @throws DatabaseException   On configuration or connection errors.
  */
 public static function getConnection($connectionName, $connectionType = self::TYPE_READ_WRITE)
 {
     if (!isset(static::$connections[$connectionName][$connectionType])) {
         $config = Config::getInstance();
         if (is_null(static::$paramPrefix)) {
             static::$paramPrefix = (string) $config->get('system.database.paramPrefix', '');
         }
         $properties = array('backendType', 'charset', 'database', 'host', 'isPersistent', 'password', 'path', 'user', 'useTraditionalStrictMode', 'timezone');
         $configData = array();
         foreach ($properties as $property) {
             try {
                 $configData[$property] = $config->get('resource.database.' . $connectionName . '.' . $connectionType . '.' . $property);
             } catch (ConfigException $e) {
                 // We just swallow this because we don't know what properties do we need in advance
             }
         }
         if (empty($configData)) {
             throw new DatabaseException('Database connection configuration "' . $connectionName . '" not found');
         }
         if (!static::validateConnectionConfig($configData)) {
             throw new DatabaseException('Invalid database config: ' . $connectionName);
         }
         static::$connections[$connectionName][$connectionType] = static::makeConnection($configData, $connectionName);
         if (self::TYPE_READ_WRITE == $connectionType || isset(static::$connections[$connectionName][self::TYPE_READ_ONLY])) {
             static::$connections[$connectionName][self::TYPE_READ_ONLY] = static::$connections[$connectionName][$connectionType];
         }
     }
     return static::$connections[$connectionName][$connectionType];
 }
Beispiel #19
0
 protected function setUp()
 {
     parent::setUp();
     Config::getInstance()->set(['resource.vend.oauth.clientId' => 'clientId', 'resource.vend.oauth.clientSecret' => 'clientSecret', 'resource.vend.oauth.redirectUri' => 'redirectUri']);
 }
 /**
  * Tears down the fixture, for example, close a network connection.
  * This method is called after a test is executed.
  *
  * @return void
  */
 protected function tearDown()
 {
     Config::getInstance()->clear();
     Application::getInstance()->getDiContainer()->getEventHandlerRegistry()->clearAll();
     parent::tearDown();
 }
Beispiel #21
0
 /**
  * Constructor.
  */
 public function __construct()
 {
     $this->timeout = Config::getInstance()->get('system.shell.executedCommandTimeout', 0);
 }
 /**
  * Runs the specified action
  *
  * @param string $action   The name of the action (without the controller specific prefix)
  *
  * @return void
  *
  * @throws \YapepBase\Exception\ControllerException   On controller specific error. (eg. action not found)
  * @throws \YapepBase\Exception\Exception             On framework related errors.
  * @throws \YapepBase\Exception\RedirectException     On redirections.
  * @throws \Exception                                 On non-framework related errors.
  */
 public function run($action)
 {
     $methodName = $this->getActionPrefix() . $action;
     if (!method_exists($this, $methodName)) {
         throw new ControllerException('Action ' . $methodName . ' does not exist in ' . get_class($this), ControllerException::ERR_ACTION_NOT_FOUND);
     }
     if (Config::getInstance()->get('system.performStrictControllerActionNameValidation', false)) {
         $reflection = new \ReflectionClass($this);
         $method = $reflection->getMethod($methodName);
         if ($method->name != $methodName) {
             throw new ControllerException('Invalid case when running action ' . $methodName . ' in ' . get_class($this) . '. The valid case is: ' . $method->name, ControllerException::ERR_ACTION_NOT_FOUND);
         }
     }
     $this->before();
     $result = $this->runAction($methodName);
     if (!empty($result) && !is_string($result) && !$result instanceof ViewAbstract) {
         throw new ControllerException('Result of the action (' . get_class($this) . '/' . $action . ') is not an instance of ViewAbstract or string', ControllerException::ERR_INVALID_ACTION_RESULT);
     }
     // We called the run method, but we did not rendered the output yet
     $this->runBeforeRender();
     $this->runBeforeResponseSet($result);
     if (!empty($result)) {
         if (is_string($result)) {
             $this->response->setRenderedBody($result);
         } else {
             $this->response->setBody($result);
         }
     }
     $this->after();
 }
Beispiel #23
0
 /**
  * Sets a cookie with the response. The params are same as for the php setCookie() function.
  * {@link http://php.net/setCookie}
  *
  * @param string $name         Cookie name.
  * @param string $value        The cookie value.
  * @param int    $expiration   The expiration timestamp.
  * @param string $path         Path.
  * @param string $domain       Cookie domain.
  * @param bool   $secure       Is the cookie HTTPS only.
  * @param bool   $httpOnly     Is the cookie HTTP only.
  *
  * @return void
  */
 public function setCookie($name, $value, $expiration = 0, $path = '/', $domain = null, $secure = false, $httpOnly = false)
 {
     if (is_null($domain)) {
         $domain = Config::getInstance()->get('system.response.defaultCookieDomain', false);
         if (false === $domain) {
             $domain = null;
         }
     }
     if ($this->isBufferingEnabled) {
         $this->cookies[$name] = array('name' => $name, 'value' => $value, 'expiration' => $expiration, 'path' => $path, 'domain' => $domain, 'secure' => $secure, 'httpOnly' => $httpOnly);
     } else {
         $this->output->setCookie($name, $value, $expiration, $path, $domain, $secure, $httpOnly);
     }
 }
 /**
  * Tears down the fixture, for example, closes a network connection.
  * This method is called after a test is executed.
  */
 protected function tearDown()
 {
     Config::getInstance()->clear();
     Application::getInstance()->setDiContainer(new SystemContainer());
 }
Beispiel #25
0
function setupMySqlDbConfig($varName, $dbName)
{
    $parsed = parse_url(getenv($varName));
    $config = Config::getInstance();
    $config->set(['resource.database.' . $dbName . '.rw.backendType' => 'mysql', 'resource.database.' . $dbName . '.rw.host' => $parsed['host'], 'resource.database.' . $dbName . '.rw.user' => $parsed['user'], 'resource.database.' . $dbName . '.rw.password' => $parsed['pass'], 'resource.database.' . $dbName . '.rw.database' => ltrim($parsed['path'], '/'), 'resource.database.' . $dbName . '.rw.port' => $parsed['port'], 'resource.database.' . $dbName . '.rw.charset' => 'utf8', 'resource.database.' . $dbName . '.ro.backendType' => 'mysql', 'resource.database.' . $dbName . '.ro.host' => $parsed['host'], 'resource.database.' . $dbName . '.ro.user' => $parsed['user'], 'resource.database.' . $dbName . '.ro.password' => $parsed['pass'], 'resource.database.' . $dbName . '.ro.database' => ltrim($parsed['path'], '/'), 'resource.database.' . $dbName . '.ro.port' => $parsed['port'], 'resource.database.' . $dbName . '.ro.charset' => 'utf8']);
}
Beispiel #26
0
 /**
  * Constructor
  *
  * @param string                        $configName     Name of the session config.
  * @param \YapepBase\Storage\IStorage   $storage        The storage object.
  * @param bool                          $autoRegister   If TRUE, it will automatically register as an event handler.
  *
  * @throws \YapepBase\Exception\ConfigException   On configuration problems
  * @throws \YapepBase\Exception\Exception         On other problems
  */
 public function __construct($configName, IStorage $storage, $autoRegister = true)
 {
     if (!$storage->isTtlSupported()) {
         throw new Exception('Storage without TTL support passed to session handler.');
     }
     $this->storage = $storage;
     $properties = array('namespace', 'lifetime');
     $properties = array_merge($properties, $this->getConfigProperties());
     $configData = array();
     foreach ($properties as $property) {
         try {
             $configData[$property] = Config::getInstance()->get('resource.session.' . $configName . '.' . $property);
         } catch (ConfigException $e) {
             // We just swallow this because we don't know what properties do we need in advance
         }
     }
     if (empty($configData)) {
         throw new ConfigException('Configuration not found for session handler: ' . $configName);
     }
     if (!isset($configData['namespace'])) {
         throw new ConfigException('No namespace has been set for the session handler: ' . $configName);
     }
     $this->validateConfig($configData);
     $this->namespace = $configData['namespace'];
     $this->lifetime = empty($configData['lifetime']) ? self::DEFAULT_LIFETIME : (int) $configData['lifetime'];
     if ($autoRegister) {
         $this->registerEventHandler();
     }
     $this->id = $this->getSessionId();
 }
 public function testRun()
 {
     $response = null;
     $controller = $this->getController($response);
     $controller->setAction(function () {
     });
     $this->assertFalse($controller->ran);
     $controller->run('Test');
     $this->assertTrue($controller->ran);
     try {
         $controller->run('nonExistent');
         $this->fail('Running a non-existent action should result in a ControllerException');
     } catch (\YapepBase\Exception\ControllerException $e) {
         $this->assertEquals(\YapepBase\Exception\ControllerException::ERR_ACTION_NOT_FOUND, $e->getCode());
     }
     $controller->setAction(function () {
         return 3.14;
     });
     try {
         $controller->run('Test');
         $this->fail('Running an action with an invalid result in a ControllerException');
     } catch (\YapepBase\Exception\ControllerException $e) {
         $this->assertEquals(\YapepBase\Exception\ControllerException::ERR_INVALID_ACTION_RESULT, $e->getCode());
     }
     $controller->setAction(function () {
         return 'test string';
     });
     $controller->run('Test');
     $this->assertEquals('test string', $response->getRenderedBody());
     $controller->setAction(function () {
         $view = new ViewMock();
         $view->set('view test string');
         return $view;
     });
     $controller->run('Test');
     $this->assertEquals('view test string', $response->getRenderedBody());
     $controller->setAction(function (MockController $controller) {
         $controller->internalRedirect('Mock', 'RedirectTarget');
     });
     try {
         $controller->run('Test');
         $this->fail('No redirectException is thrown');
     } catch (RedirectException $exception) {
     }
     $this->assertEquals('redirect test', $response->getRenderedBody());
     // Test if the action is run with an invalid case with no strict checking
     $controller->setAction(function (MockController $controller) {
         return 'test';
     });
     $controller->run('test');
     $this->assertTrue($controller->ran, 'The action should have been run with an invalid case in the action and no strict checking enabled');
     // Test if the action is run with an invalid case with strict checking enabled
     Config::getInstance()->set('system.performStrictControllerActionNameValidation', true);
     $controller->setAction(function (MockController $controller) {
         return 'test';
     });
     try {
         $controller->run('test');
         $this->fail('There should be a ControllerException thrown when running an action with an invalid case' . ' and strict checking is enabled');
     } catch (ControllerException $e) {
         $this->assertEquals(ControllerException::ERR_ACTION_NOT_FOUND, $e->getCode(), 'The exception should have a code for action not found');
         $this->assertContains('Invalid case', $e->getMessage(), 'The error message should contain invalid case');
     }
     $this->assertFalse($controller->ran, 'The action should not have been run with an invalid case in the action and strict checking enabled');
     // Test that strict checking doesn't affect running a correctly named action
     $controller->setAction(function (MockController $controller) {
         return 'test';
     });
     $controller->run('Test');
     $this->assertTrue($controller->ran, 'The action should have been run with a valid case in the action and strict checking enabled');
 }
Beispiel #28
0
 /**
  * Runs after each test
  *
  * @return void
  */
 protected function tearDown()
 {
     parent::tearDown();
     Application::getInstance()->setDiContainer($this->originalDiContainer);
     Config::getInstance()->clear();
 }
Beispiel #29
0
<?php

/**
 * Configurations of the application.
 */
use YapepBase\Config;
Config::getInstance()->set(array('application.name' => 'Www'));
Beispiel #30
0
 /**
  * Returns the debug data URL for the specified error ID or an empty string, if the debug data url is not
  * configured properly.
  *
  * @param string $errorId   The error ID.
  *
  * @return string
  */
 protected function getDebugDataUrl($errorId)
 {
     $config = Config::getInstance();
     $urlTemplate = $config->get('system.debugger.errorDebugUrlTemplate', '');
     $paramName = $config->get('system.debugger.errorDebugUrlParamName', '');
     if (empty($urlTemplate) || empty($paramName)) {
         return '';
     }
     return str_replace($paramName, $errorId, $urlTemplate);
 }