protected function setUp() { $this->application = new Application(); $this->application->unitTesting = true; $this->application->context()->simulateNonCli = false; $this->application->registerModule(new UnitTestingModule()); $this->application->initialiseModules(); ExceptionHandler::disableExceptionTrapping(); }
<?php namespace Your\WebApp; use Rhubarb\Crown\Context; use Rhubarb\Crown\Exceptions\Handlers\ExceptionHandler; use Rhubarb\Crown\Logging\Log; use Rhubarb\Crown\Logging\PhpLog; use Rhubarb\Stem\StemSettings; $dbSettings = new StemSettings(); $dbSettings->Host = "localhost"; $dbSettings->Username = "******"; $dbSettings->Password = ""; $dbSettings->Database = "ogredb"; // Add a PHP logger Log::attachLog(new PhpLog(Log::ALL)); $con = new Context(); $con->DeveloperMode = true; // Switch off exception trapping. You should have this on in the production environment. ExceptionHandler::disableExceptionTrapping();
public function testDisablingTrapping() { ExceptionHandler::disableExceptionTrapping(); try { // Enable layouts for this test as proof the URL handler has intercepted the response. LayoutModule::enableLayout(); $request = new WebRequest(); $request->UrlPath = "/test-exception/"; $response = Module::generateResponseForRequest($request); $this->fail("Without exception trapping this line should not be reached."); } catch (RhubarbException $er) { } ExceptionHandler::setExceptionHandlerClassName('\\Rhubarb\\Crown\\Tests\\Exceptions\\Handlers\\UnitTestDisobedientExceptionHandler'); try { // Enable layouts for this test as proof the URL handler has intercepted the response. LayoutModule::enableLayout(); $request = new WebRequest(); $request->UrlPath = "/test-exception/"; $response = Module::generateResponseForRequest($request); } catch (RhubarbException $er) { $this->fail("The extended exception handler should force handling of exceptions even if trapping is disabled."); } ExceptionHandler::enableExceptionTrapping(); LayoutModule::disableLayout(); }
public function testHeadItems() { // Reenable this as it was disabled in the previous test. ExceptionHandler::enableExceptionTrapping(); LayoutModule::addHeadItem("this is some html"); LayoutModule::addHeadItem("this is more html"); $head = LayoutModule::getHeadItemsAsHtml(); $this->assertEquals("this is some html\nthis is more html", $head); }
<?php /** * Copyright (c) 2016 RhubarbPHP. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * A bootstrapper to setup the Rhubarb platform when running scripts from a terminal */ // Initiate our bootstrap script to boot all libraries required. require_once __DIR__ . "/boot-application.php"; // Disable exception trapping as there will be no valid URL handler able to return a sensible // interpretation of the exception details. CLI scripts are never seen publicly so it is more // useful to have the real exception text and isn't a security risk. \Rhubarb\Crown\Exceptions\Handlers\ExceptionHandler::disableExceptionTrapping(); if (isset($argv[1])) { $script = $argv[1]; /** @noinspection PhpIncludeInspection */ include $script; }
public final function __construct() { global $unitTesting; parent::__construct(); $this->phpContext = new PhpContext(); // $unitTesting is set in execute-test.php $this->unitTesting = isset($unitTesting) && $unitTesting ? true : false; $this->developerMode = false; $this->live = false; $this->applicationRootPath = APPLICATION_ROOT_DIR; $this->setAsRunningApplication(); ExceptionHandler::setProviderClassName(DefaultExceptionHandler::class); SessionProvider::setProviderClassName(PhpSessionProvider::class); ResourceDeploymentProvider::setProviderClassName(RelocationResourceDeploymentProvider::class); $this->registerModule($this); }
/** * Generates the response content for the client. * * This is normally called by platform/execute-http.php and must be called after all * modules have been registered to guarantee the correct output. * * @static * @param Request\Request $request * @return string */ public static function generateResponseForRequest(Request\Request $request) { // Set the current request to be this one. $context = new Context(); $context->Request = $request; $additionalData = []; if ($request instanceof WebRequest) { if (!empty($request->GetData)) { $additionalData = $request->GetData; } } Log::createEntry(Log::PERFORMANCE_LEVEL | Log::DEBUG_LEVEL, function () use($request) { if ($request instanceof WebRequest) { return "Generating response for url " . $request->UrlPath; } if ($request instanceof CliRequest) { return "Starting CLI response"; } return ""; }, "ROUTER", $additionalData); Log::indent(); $handlers = self::getAllUrlHandlers(); // an empty-string Response to fall back on if nothing else is generated $response = new HtmlResponse(); $response->SetContent(''); $filterResponse = true; try { // Iterate over each handler and ask them to generate a response. // If they do return a response we return that and exit the loop. // If they return false then we assume they couldn't handle the URL // and continue to the next handler. foreach ($handlers as $handler) { $generatedResponse = $handler->generateResponse($request); if ($generatedResponse !== false) { Log::Debug(function () use($handler) { return ["Handler `" . get_class($handler) . "` generated response.", []]; }, "ROUTER"); // it should be preferred for a handler to return a Response object, // but checking this here retains the option for them to just return // their output if ($generatedResponse instanceof Response) { $response = $generatedResponse; } else { $response->setContent($generatedResponse); } break; } } } catch (ForceResponseException $er) { $response = $er->getResponse(); $filterResponse = false; } catch (StopGeneratingResponseException $er) { $filterResponse = false; } catch (RhubarbException $er) { $response = ExceptionHandler::processException($er); } catch (\Exception $er) { $response = ExceptionHandler::processException(new NonRhubarbException($er)); } if ($filterResponse) { Log::createEntry(Log::PERFORMANCE_LEVEL | Log::DEBUG_LEVEL, "Output filters started", "ROUTER"); Log::indent(); $filters = self::getAllResponseFilters(); foreach ($filters as $filter) { $response = $filter->processResponse($response); } Log::createEntry(Log::PERFORMANCE_LEVEL | Log::DEBUG_LEVEL, "Output filters finished", "ROUTER"); Log::outdent(); } Log::performance("Response generated", "ROUTER"); Log::outdent(); return $response; }
use Rhubarb\Crown\Exceptions\Handlers\ExceptionHandler; use Rhubarb\Crown\Module; error_reporting(E_ALL | E_STRICT); // As we preform our own exception handling we need to stop fatal errors from showing stack traces. ini_set("display_errors", "off"); // Include the composer autoloader /** @noinspection PhpIncludeInspection */ include "vendor/autoload.php"; // Initially we don't have an auto loader as this is handled by the modules. We need to load this first // module 'core' so that we have an auto loader for subsequent modules. There are also some other classes // that might be needed by this booting script so we load them aswell. include __DIR__ . "/../src/Module.php"; include __DIR__ . "/../src/Exceptions/ImplementationException.php"; include __DIR__ . "/../src/Exceptions/Handlers/ExceptionHandler.php"; // Register to handle exceptions and PHP errors. However we don't do this if we are unit testing. It's // best to let the exceptions report unhindered to phpunit. if (!isset($unitTesting) || !$unitTesting) { ExceptionHandler::EnableExceptionTrapping(); } $appName = "app"; // Is there an app environment setting? This allows the same project to serve multiple solutions // with one code base (e.g. tenant and landlord together). This is very rare in production systems, however // for the initial project phase this can be very useful. if ($envAppSetting = getenv("rhubarb_app")) { $appName .= "-" . $envAppSetting; } if (file_exists("settings/" . $appName . ".config.php")) { include "settings/" . $appName . ".config.php"; } // Now auto loaders are in place we can initialise the modules properly. Module::InitialiseModules();
public function testDisablingTrapping() { ExceptionHandler::disableExceptionTrapping(); try { // Enable layouts for this test as proof the URL handler has intercepted the response. LayoutModule::enableLayout(); $request = new WebRequest(); $request->urlPath = "/test-exception/"; $response = $this->application->generateResponseForRequest($request); $this->fail("Without exception trapping this line should not be reached."); } catch (RhubarbException $er) { } $this->application->container()->registerClass(ExceptionHandler::class, UnitTestDisobedientExceptionHandler::class); try { // Enable layouts for this test as proof the URL handler has intercepted the response. LayoutModule::enableLayout(); $request = new WebRequest(); $request->urlPath = "/test-exception/"; $response = $this->application->generateResponseForRequest($request); } catch (RhubarbException $er) { $this->fail("The extended exception handler should force handling of exceptions even if trapping is disabled."); } ExceptionHandler::enableExceptionTrapping(); LayoutModule::disableLayout(); }