Changeset 2082

Show
Ignore:
Timestamp:
02/10/09 13:48:36 (18 months ago)
Author:
mikey
Message:

implement refactoring #197: Turn stubMode from enum into instantiable class

Location:
framework/trunk/src
Files:
2 added
12 modified

Legend:

Unmodified
Added
Removed

  • framework/trunk/src/main/php/net/stubbles/lang/errorhandler/stubExceptionHandler.php

    r1763 r2082  
    33 * Interface for exception handlers. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  lang_errorhandler 
     7 * @version     $Id$ 
    88 */ 
    99/** 
    … …  
    2323    public function handleException(Exception $exception); 
    2424} 
     25?> 

  • framework/trunk/src/main/php/net/stubbles/lang/stubMode.php

    r1763 r2082  
    11<?php 
    22/** 
    3  * Enum for different runtime modes of Stubbles. 
     3 * Handlings for different runtime modes of Stubbles. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  lang 
     7 * @version     $Id$ 
    88 */ 
    9 stubClassLoader::load('net::stubbles::lang::stubEnum', 
    10                       'net::stubbles::lang::exceptions::stubIllegalArgumentException' 
    11 ); 
     9stubClassLoader::load('net::stubbles::lang::exceptions::stubIllegalArgumentException'); 
    1210/** 
    13  * Enum for different runtime modes of Stubbles. 
     11 * Handlings for different runtime modes of Stubbles. 
    1412 * 
    15  * The mode instances contain information about which exception handler and 
     13 * The mode instance contains information about which exception handler and 
    1614 * which error handler should be used, else well as whether caching is enabled 
    17  * or not. Currently, there are four different modes available: 
    18  * stubMode::$PROD 
     15 * or not. Currently, there are four different default modes available: 
     16 * stubMode::prod() 
    1917 *      - uses exception handler net::stubbles::lang::errorhandler::stubProdModeExceptionHandler 
    2018 *      - uses default error handler net::stubbles::lang::errorhandler::stubDefaultErrorHandler 
    2119 *      - caching enabled 
    22  * stubMode::$TEST 
     20 * stubMode::test() 
    2321 *      - uses exception handler net::stubbles::lang::errorhandler::stubDisplayExceptionHandler 
    2422 *      - uses default error handler net::stubbles::lang::errorhandler::stubDefaultErrorHandler 
    2523 *      - caching enabled 
    26  * stubMode::$STAGE 
     24 * stubMode::stage() 
    2725 *      - uses exception handler net::stubbles::lang::errorhandler::stubDisplayExceptionHandler 
    2826 *      - no error handler 
    2927 *      - caching disabled 
    30  * stubMode::$DEV 
     28 * stubMode::dev() 
    3129 *      - uses exception handler net::stubbles::lang::errorhandler::stubDisplayExceptionHandler 
    3230 *      - no error handler 
    … …  
    3432 * While stage and dev mode currently are not different this may change in 
    3533 * future in case new mode depending switches become neccessary. 
     34 * 
    3635 * To change the exception and/or error handler to be used, set the new ones 
    3736 * via setExceptionHandler()/setErrorHandler(). 
    … …  
    3938 * this is not done automatically, regardless whether you set your own ones or 
    4039 * not. Use registerExceptionHandler() and registerErrorHandler() to do so. 
    41  *  
    42  * Additionally there exists stubMode::$CURRENT. This points to the currently 
    43  * selected mode. Without further action this is stubMode::$PROD. You can set 
    44  * the current mode with stubMode::setCurrent(). 
    4540 * 
    4641 * @package     stubbles 
    4742 * @subpackage  lang 
    4843 */ 
    49 class stubMode extends stubEnum 
     44class stubMode extends stubBaseObject 
    5045{ 
    5146    /** 
    … …  
    5853    const HANDLER_INSTANCE      = 'instance'; 
    5954    /** 
    60      * mode: production 
    61      * 
    62      * @var  stubMode 
    63      */ 
    64     public static $PROD; 
    65     /** 
    66      * mode: test 
    67      * 
    68      * @var  stubMode 
    69      */ 
    70     public static $TEST; 
    71     /** 
    72      * mode: stage 
    73      * 
    74      * @var  stubMode 
    75      */ 
    76     public static $STAGE; 
    77     /** 
    78      * mode: development 
    79      * 
    80      * @var  stubMode 
    81      */ 
    82     public static $DEV; 
    83     /** 
    84      * current selected mode, default: PROD 
    85      * 
    86      * @var  stubMode 
     55     * current selected mode 
     56     * 
     57     * This is for backwards compatibility only. 
     58     * 
     59     * @var         stubMode 
     60     * @deprecated 
    8761     */ 
    8862    public static $CURRENT; 
    8963    /** 
     64     * name of mode 
     65     * 
     66     * @var  string 
     67     */ 
     68    protected $modeName; 
     69    /** 
    9070     * exception handler to be used in the mode 
    9171     * 
    … …  
    10787 
    10888    /** 
    109      * static initializing 
    110      */ 
    111     // @codeCoverageIgnoreStart 
    112     public static function __static() 
    113     { 
    114         // production mode 
    115         self::$PROD                     = new self('PROD', 0); 
    116         self::$PROD->exceptionHandler   = array('class'  => 'net::stubbles::lang::errorhandler::stubProdModeExceptionHandler', 
    117                                                 'method' => 'handleException', 
    118                                                 'type'   => self::HANDLER_INSTANCE 
    119                                           ); 
    120         self::$PROD->errorHandler       = array('class'  => 'net::stubbles::lang::errorhandler::stubDefaultErrorHandler', 
    121                                                 'method' => 'handle', 
    122                                                 'type'   => self::HANDLER_INSTANCE 
    123                                           ); 
    124          
    125         // test mode 
    126         self::$TEST                     = new self('TEST', 1); 
    127         self::$TEST->exceptionHandler   = array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
    128                                                 'method' => 'handleException', 
    129                                                 'type'   => self::HANDLER_INSTANCE 
    130                                           ); 
    131         self::$TEST->errorHandler       = array('class'  => 'net::stubbles::lang::errorhandler::stubDefaultErrorHandler', 
    132                                                 'method' => 'handle', 
    133                                                 'type'   => self::HANDLER_INSTANCE 
    134                                           ); 
    135          
    136         // stage mode 
    137         self::$STAGE                    = new self('STAGE', 2); 
    138         self::$STAGE->exceptionHandler  = array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
    139                                                 'method' => 'handleException', 
    140                                                 'type'   => self::HANDLER_INSTANCE 
    141                                           ); 
    142         self::$STAGE->cacheEnabled      = false; 
    143          
    144         // development mode 
    145         self::$DEV                      = new self('DEV', 3); 
    146         self::$DEV->exceptionHandler    = array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
    147                                                 'method' => 'handleException', 
    148                                                 'type'   => self::HANDLER_INSTANCE 
    149                                           ); 
    150         self::$DEV->cacheEnabled        = false; 
    151          
    152         // current mode, by default PROD 
    153         self::$CURRENT                  = self::$PROD; 
    154     } 
    155     // @codeCoverageIgnoreEnd 
    156  
    157     /** 
    15889     * sets the current mode 
    15990     * 
    160      * @param  stubMode  $mode 
     91     * This is for backwards compatibility only. 
     92     * 
     93     * @param       stubMode  $mode 
     94     * @deprecated 
    16195     */ 
    16296    public static function setCurrent(self $mode) 
    … …  
    166100 
    167101    /** 
     102     * constructor 
     103     * 
     104     * Use this to create your own mode. However you might want to use one of 
     105     * the four default modes delivered by this class, see below for the static 
     106     * constructor methods prod(), test(), stage() and dev(). 
     107     * 
     108     * @param  string                $modeName 
     109     * @param  array<string,string>  $exceptionHandler 
     110     * @param  array<string,string>  $errorHandler 
     111     * @param  bool                  $cacheEnabled 
     112     */ 
     113    public function __construct($modeName, array $exceptionHandler, array $errorHandler, $cacheEnabled) 
     114    { 
     115        $this->modeName         = $modeName; 
     116        $this->exceptionHandler = ((count($exceptionHandler) > 0) ? ($exceptionHandler) : (null)); 
     117        $this->errorHandler     = ((count($errorHandler) > 0) ? ($errorHandler) : (null)); 
     118        $this->cacheEnabled     = $cacheEnabled; 
     119        self::setCurrent($this); 
     120    } 
     121 
     122    /** 
     123     * creates default production mode 
     124     * 
     125     * - exceptions will be logged, error 500 will be shown instead of exception 
     126     * - default error handling for PHP errors 
     127     * - caching enabled 
     128     * 
     129     * @return  stubMode 
     130     */ 
     131    public static function prod() 
     132    { 
     133        return new self('PROD', 
     134                        array('class'  => 'net::stubbles::lang::errorhandler::stubProdModeExceptionHandler', 
     135                              'method' => 'handleException', 
     136                              'type'   => self::HANDLER_INSTANCE 
     137                        ), 
     138                        array('class'  => 'net::stubbles::lang::errorhandler::stubDefaultErrorHandler', 
     139                              'method' => 'handle', 
     140                              'type'   => self::HANDLER_INSTANCE 
     141                        ), 
     142                        true 
     143               ); 
     144    } 
     145 
     146    /** 
     147     * creates default test mode 
     148     * 
     149     * - exceptions will be displayed 
     150     * - default error handling for PHP errors 
     151     * - caching enabled 
     152     * 
     153     * @return  stubMode 
     154     */ 
     155    public static function test() 
     156    { 
     157        return new self('TEST', 
     158                        array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
     159                              'method' => 'handleException', 
     160                              'type'   => self::HANDLER_INSTANCE 
     161                        ), 
     162                        array('class'  => 'net::stubbles::lang::errorhandler::stubDefaultErrorHandler', 
     163                              'method' => 'handle', 
     164                              'type'   => self::HANDLER_INSTANCE 
     165                        ), 
     166                        true 
     167               ); 
     168    } 
     169 
     170    /** 
     171     * creates default stage mode 
     172     * 
     173     * - exceptions will be displayed 
     174     * - no error handling for PHP errors 
     175     * - caching disabled 
     176     * 
     177     * @return  stubMode 
     178     */ 
     179    public static function stage() 
     180    { 
     181        return new self('STAGE', 
     182                        array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
     183                              'method' => 'handleException', 
     184                              'type'   => self::HANDLER_INSTANCE 
     185                        ), 
     186                        array(), 
     187                        false 
     188               ); 
     189    } 
     190 
     191    /** 
     192     * creates default dev mode 
     193     * 
     194     * - exceptions will be displayed 
     195     * - no error handling for PHP errors 
     196     * - caching disabled 
     197     * 
     198     * @return  stubMode 
     199     */ 
     200    public static function dev() 
     201    { 
     202        return new self('DEV', 
     203                        array('class'  => 'net::stubbles::lang::errorhandler::stubDisplayExceptionHandler', 
     204                              'method' => 'handleException', 
     205                              'type'   => self::HANDLER_INSTANCE 
     206                        ), 
     207                        array(), 
     208                        false 
     209               ); 
     210    } 
     211 
     212    /** 
     213     * returns the name of the mode 
     214     * 
     215     * @return  string 
     216     */ 
     217    public function name() 
     218    { 
     219        return $this->modeName; 
     220    } 
     221 
     222    /** 
    168223     * sets the exception handler to given class and method name 
    169224     * 
    170225     * To register the new exception handler call registerExceptionHandler(). 
    171226     * 
    172      * @param  string|object  $class        name or instance of exception handler class 
    173      * @param  string         $methodName   name of exception handler method 
    174      * @param  string         $type         optional  whether method has to be called statically or via an instance 
     227     * @param   string|object  $class        name or instance of exception handler class 
     228     * @param   string         $methodName   name of exception handler method 
     229     * @param   string         $type         optional  whether method has to be called statically or via an instance 
     230     * @return  stubMode 
    175231     */ 
    176232    public function setExceptionHandler($class, $methodName, $type = self::HANDLER_INSTANCE) 
    … …  
    180236                                        'type'   => $type 
    181237                                  ); 
     238        return $this; 
    182239    } 
    183240 
    … …  
    211268     * To register the new error handler call registerErrorHandler(). 
    212269     * 
    213      * @param  string|object  $class        name or instance of error handler class 
    214      * @param  string         $methodName   name of error handler method 
    215      * @param  string         $type         optional  whether method has to be called statically or via an instance 
     270     * @param   string|object  $class        name or instance of error handler class 
     271     * @param   string         $methodName   name of error handler method 
     272     * @param   string         $type         optional  whether method has to be called statically or via an instance 
     273     * @return  stubMode 
    216274     */ 
    217275    public function setErrorHandler($class, $methodName, $type = self::HANDLER_INSTANCE) 
    … …  
    221279                                    'type'   => $type 
    222280                              ); 
     281        return $this; 
    223282    } 
    224283 

  • framework/trunk/src/main/php/net/stubbles/websites/ioc/stubWebsiteBindingModule.php

    r2081 r2082  
    166166        if ($binder->getInjector()->hasExplicitBinding('stubMode') === false) { 
    167167            if (null === $this->mode) { 
    168                 $this->mode = stubMode::$PROD; 
     168                $this->mode = stubMode::prod(); 
    169169            } 
    170170             

  • framework/trunk/src/test/php/net/stubbles/ioc/stubAppTestCase.php

    r2081 r2082  
    172172                                                          ), 
    173173                                                          stubWebsiteBindingModule::createWithXmlProcessorAsDefault() 
    174                                                                                   ->runningInMode(stubMode::$DEV) 
     174                                                                                  ->runningInMode(stubMode::dev()) 
    175175                           ); 
    176176        $this->assertType('stubFrontController', $frontController); 

  • framework/trunk/src/test/php/net/stubbles/lang/stubModeTestCase.php

    r1763 r2082  
    33 * Tests for net::stubbles::lang::stubMode. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  lang_test 
     7 * @version     $Id$ 
    88 */ 
    99stubClassLoader::load('net::stubbles::lang::stubMode', 
    … …  
    1111); 
    1212/** 
    13  * Mock class to be used as error handler. 
     13 * Tests for net::stubbles::lang::stubMode. 
    1414 * 
    15  * @package     stubbles 
    16  * @subpackage  lang_test 
    17  */ 
    18 class stubModestubErrorHandler extends stubBaseObject implements stubErrorHandler 
    19 { 
    20     /** 
    21      * checks whether this error handler is responsible for the given error 
    22      * 
    23      * @param   int     $level    level of the raised error 
    24      * @param   string  $message  error message 
    25      * @param   string  $file     optional  filename that the error was raised in 
    26      * @param   int     $line     optional  line number the error was raised at 
    27      * @param   array   $context  optional  array of every variable that existed in the scope the error was triggered in 
    28      * @return  bool    true if error handler is responsible, else false 
    29      */ 
    30     public function isResponsible($level, $message, $file = null, $line = null, array $context = array()) {} 
    31  
    32     /** 
    33      * checks whether this error is supressable 
    34      *  
    35      * This method is called in case the level is 0. It decides whether the  
    36      * error has to be handled or if it can be omitted. 
    37      * 
    38      * @param   int     $level    level of the raised error 
    39      * @param   string  $message  error message 
    40      * @param   string  $file     optional  filename that the error was raised in 
    41      * @param   int     $line     optional  line number the error was raised at 
    42      * @param   array   $context  optional  array of every variable that existed in the scope the error was triggered in 
    43      * @return  bool    true if error is supressable, else false 
    44      */ 
    45     public function isSupressable($level, $message, $file = null, $line = null, array $context = array()) {} 
    46  
    47     /** 
    48      * handles the given error 
    49      * 
    50      * @param   int     $level    level of the raised error 
    51      * @param   string  $message  error message 
    52      * @param   string  $file     optional  filename that the error was raised in 
    53      * @param   int     $line     optional  line number the error was raised at 
    54      * @param   array   $context  optional  array of every variable that existed in the scope the error was triggered in 
    55      * @return  bool    true if error message should populate $php_errormsg, else false 
    56      * @throws  stubException  error handlers are allowed to throw every exception they want to 
    57      */ 
    58     public function handle($level, $message, $file = null, $line = null, array $context = array()) {} 
    59 } 
    60 /** 
    61  * Concrete instance of net::stubbles::lang::stubMode. 
    62  * 
    63  * @package     stubbles 
    64  * @subpackage  lang_test 
    65  */ 
    66 class TeststubMode extends stubMode 
    67 { 
    68     /** 
    69      * we just need a test instance 
    70      * 
    71      * @var  TeststubMode 
    72      */ 
    73     public static $FOO; 
    74  
    75     /** 
    76      * initialize the test instance 
    77      */ 
    78     public static function init() 
    79     { 
    80         self::$FOO = new self('FOO'); 
    81     } 
    82  
    83     /** 
    84      * returns the class name 
    85      * 
    86      * @return  string 
    87      */ 
    88     public function getClassName() 
    89     { 
    90         return 'net::stubbles::lang::test::TeststubMode'; 
    91     } 
    92  
    93     /** 
    94      * returns the exception handler 
    95      * 
    96      * @return  array 
    97      */ 
    98     public function getExceptionHandler() 
    99     { 
    100         return $this->exceptionHandler; 
    101     } 
    102  
    103     /** 
    104      * returns the error handler 
    105      * 
    106      * @return  array 
    107      */ 
    108     public function getErrorHandler() 
    109     { 
    110         return $this->errorHandler; 
    111     } 
    112  
    113     /** 
    114      * helper method to access the protected getCallback() method 
    115      * 
    116      * @param   array     $handler 
    117      * @return  callback 
    118      */ 
    119     public function retrieveCallback(array &$handler) 
    120     { 
    121         return $this->getCallback($handler); 
    122     } 
    123 } 
    124 TeststubMode::init(); 
    125 /** 
    126  * Tests for net::stubbles::lang::stubMode. 
     15 * All tests that do not require restoring the error or exception handler. 
    12716 * 
    12817 * @package     stubbles 
    … …  
    13221class stubModeTestCase extends PHPUnit_Framework_TestCase 
    13322{ 
    134     /** 
    135      * set up test environment 
    136      */ 
    137     public function setUp() 
    138     { 
    139         stubMode::setCurrent(stubMode::$PROD); 
    140     } 
    141  
    142     /** 
    143      * clean up test environment 
    144      */ 
    145     public function tearDown() 
    146     { 
    147         stubMode::setCurrent(stubMode::$PROD); 
    148     } 
    14923 
    15024    /** 
    … …  
    15226     * 
    15327     * @test 
     28     * @expectedException  stubIllegalArgumentException 
    15429     */ 
    155     public function getCallbackWithStatic() 
     30    public function getCallbackExceptionHandlerWithStaticButInstanceGiven() 
    15631    { 
    157         $handler = array('class'  => 'stubModestubErrorHandler', 
    158                          'method' => 'handle', 
    159                          'type'   => stubMode::HANDLER_STATIC 
    160                    ); 
    161         $this->assertEquals(array('stubModestubErrorHandler', 'handle'), 
    162                             TeststubMode::$FOO->retrieveCallback($handler) 
    163         ); 
     32        $instance = new stdClass(); 
     33        $handler  = array('class'  => $instance, 
     34                          'method' => 'handleException', 
     35                          'type'   => stubMode::HANDLER_STATIC 
     36                    ); 
     37        $mode     = new stubMode('FOO', $handler, array(), false); 
     38        $mode->registerExceptionHandler(); 
    16439    } 
    16540 
    … …  
    17045     * @expectedException  stubIllegalArgumentException 
    17146     */ 
    172     public function getCallbackWithStaticButInstanceGiven() 
     47    public function getCallbackErrorHandlerWithStaticButInstanceGiven() 
    17348    { 
    174         $instance = new stubModestubErrorHandler(); 
     49        $instance = new stdClass(); 
    17550        $handler  = array('class'  => $instance, 
    17651                          'method' => 'handle', 
    17752                          'type'   => stubMode::HANDLER_STATIC 
    17853                    ); 
    179         TeststubMode::$FOO->retrieveCallback($handler); 
     54        $mode     = new stubMode('FOO', array(), $handler, false); 
     55        $mode->registerErrorHandler(); 
    18056    } 
    18157 
    … …  
    18561     * @test 
    18662     */ 
    187     public function getCallbackWithInstanceFromClassname() 
     63    public function noErrorHandler() 
    18864    { 
    189         $handler  = array('class'  => 'stubModestubErrorHandler', 
    190                           'method' => 'handle', 
    191                           'type'   => stubMode::HANDLER_INSTANCE 
    192                     ); 
    193         $callback = TeststubMode::$FOO->retrieveCallback($handler); 
    194         $this->assertType('stubModestubErrorHandler', $callback[0]); 
    195         $this->assertEquals('handle', $callback[1]); 
     65        $mode = new stubMode('FOO', array(), array(), false); 
     66        $this->assertFalse($mode->registerErrorHandler()); 
    19667    } 
    19768 
    … …  
    20172     * @test 
    20273     */ 
    203     public function getCallbackWithInstanceFromInstance() 
     74    public function noExceptionHandler() 
    20475    { 
    205         $instance = new stubModestubErrorHandler(); 
    206         $handler  = array('class'  => $instance, 
    207                           'method' => 'handle', 
    208                           'type'   => stubMode::HANDLER_INSTANCE 
    209                     ); 
    210         $callback = TeststubMode::$FOO->retrieveCallback($handler); 
    211         $this->assertSame($instance, $callback[0]); 
    212         $this->assertEquals('handle', $callback[1]); 
     76        $mode = new stubMode('FOO', array(), array(), false); 
     77        $this->assertFalse($mode->registerExceptionHandler()); 
    21378    } 
    21479 
    … …  
    22085    public function cacheEnabled() 
    22186    { 
    222         $this->assertTrue(stubMode::$PROD->isCacheEnabled()); 
    223         $this->assertTrue(stubMode::$TEST->isCacheEnabled()); 
    224         $this->assertFalse(stubMode::$STAGE->isCacheEnabled()); 
    225         $this->assertFalse(stubMode::$DEV->isCacheEnabled()); 
     87        $this->assertTrue(stubMode::prod()->isCacheEnabled()); 
     88        $this->assertTrue(stubMode::test()->isCacheEnabled()); 
     89        $this->assertFalse(stubMode::stage()->isCacheEnabled()); 
     90        $this->assertFalse(stubMode::dev()->isCacheEnabled()); 
    22691    } 
    22792 
    … …  
    23398    public function noErrorHandlerForStageAndDevMode() 
    23499    { 
    235         $this->assertFalse(stubMode::$STAGE->registerErrorHandler()); 
    236         $this->assertFalse(stubMode::$DEV->registerErrorHandler()); 
     100        $this->assertFalse(stubMode::stage()->registerErrorHandler()); 
     101        $this->assertFalse(stubMode::dev()->registerErrorHandler()); 
    237102    } 
    238103 
    239104    /** 
    240      * test that the exception handler is set correct 
    241      * 
    242      * @test 
    243      */ 
    244     public function setExceptionHandler() 
    245     { 
    246         TeststubMode::$FOO->setExceptionHandler('class', 'method', stubMode::HANDLER_INSTANCE); 
    247         $this->assertEquals(array('class'  => 'class', 
    248                                   'method' => 'method', 
    249                                   'type'   => stubMode::HANDLER_INSTANCE 
    250                             ), 
    251                             TeststubMode::$FOO->getExceptionHandler() 
    252         ); 
    253     } 
    254  
    255     /** 
    256      * test that the error handler is set correct 
    257      * 
    258      * @test 
    259      */ 
    260     public function setErrorHandler() 
    261     { 
    262         TeststubMode::$FOO->setErrorHandler('class', 'method', stubMode::HANDLER_STATIC); 
    263         $this->assertEquals(array('class'  => 'class', 
    264                                   'method' => 'method', 
    265                                   'type'   => stubMode::HANDLER_STATIC 
    266                             ), 
    267                             TeststubMode::$FOO->getErrorHandler() 
    268         ); 
    269     } 
    270  
    271     /** 
    272      * test that current mode is a reference to the selected mode 
     105     * test that current mode is a reference to the created mode 
    273106     * 
    274107     * @test 
    … …  
    276109    public function current() 
    277110    { 
    278         // PROD is the default current mode 
    279         $this->assertSame(stubMode::$PROD, stubMode::$CURRENT); 
    280         stubMode::setCurrent(stubMode::$DEV); 
    281         $this->assertSame(stubMode::$DEV, stubMode::$CURRENT); 
     111        $prodMode = stubMode::prod(); 
     112        $this->assertSame($prodMode, stubMode::$CURRENT); 
    282113    } 
    283114} 

  • framework/trunk/src/test/php/net/stubbles/service/jsonrpc/subprocessors/stubJsonRpcAbstractGenerateSubProcessorTestCase.php

    r1763 r2082  
    33 * Test for net::stubbles::service::jsonrpc::subprocessors::stubJsonRpcAbstractGenerateSubProcessor. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  service_jsonrpc_subprocessors_test 
     7 * @version     $Id$ 
    88 */ 
    99stubClassLoader::load('net::stubbles::service::jsonrpc::subprocessors::stubJsonRpcAbstractGenerateSubProcessor'); 
    … …  
    123123    public function handleExceptionInProdMode() 
    124124    { 
    125         stubMode::setCurrent(stubMode::$PROD); 
     125        stubMode::setCurrent(stubMode::prod()); 
    126126        $exception = new Exception('exceptionMessage'); 
    127127        $this->mockResponse->expects($this->never())->method('write'); 
    … …  
    136136    public function handleExceptionInOtherMode() 
    137137    { 
    138         stubMode::setCurrent(stubMode::$DEV); 
     138        stubMode::setCurrent(stubMode::dev()); 
    139139        $exception = new Exception('exceptionMessage'); 
    140140        $this->mockResponse->expects($this->exactly(2))->method('write'); 

  • framework/trunk/src/test/php/net/stubbles/stubTestSuite.php

    r2060 r2082  
    3030        $suite->addTestFile($dir . '/lang/stubBaseObjectTestCase.php'); 
    3131        $suite->addTestFile($dir . '/lang/stubEnumTestCase.php'); 
     32        $suite->addTestFile($dir . '/lang/stubModeErrorHandlerTestCase.php'); 
     33        $suite->addTestFile($dir . '/lang/stubModeExceptionHandlerTestCase.php'); 
    3234        $suite->addTestFile($dir . '/lang/stubModeTestCase.php'); 
    3335        $suite->addTestFile($dir . '/lang/stubPathRegistryTestCase.php'); 

  • framework/trunk/src/test/php/net/stubbles/websites/cache/stubGzipWebsiteCacheTestCase.php

    r1944 r2082  
    33 * Tests for net::stubbles::websites::cache::stubGzipWebsiteCache. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  websites_cache_test 
     7 * @version     $Id$ 
    88 */ 
    99stubClassLoader::load('net::stubbles::websites::cache::stubGzipWebsiteCache'); 
    … …  
    200200    public function store() 
    201201    { 
    202         stubMode::setCurrent(stubMode::$PROD); 
    203202        $this->mockResponse->expects($this->any())->method('getData')->will($this->returnValue('fooContent$SIDbla$SESSION_NAMEblub$SESSION_ID')); 
    204203        $this->mockWebsiteCache->expects($this->once()) 

  • framework/trunk/src/test/php/net/stubbles/websites/ioc/stubWebsiteBindingModuleTestCase.php

    r2081 r2082  
    5252                                ->enableJsonRpc() 
    5353                                ->enableRss() 
    54                                 ->runningInMode(stubMode::$DEV) 
     54                                ->runningInMode(stubMode::dev()) 
    5555                                ->configure($this->binder); 
    5656         
    … …  
    8787                                ->enableJsonRpc('interceptors-bar') 
    8888                                ->enableRss('interceptors-baz') 
    89                                 ->runningInMode(stubMode::$DEV) 
     89                                ->runningInMode(stubMode::dev()) 
    9090                                ->configure($this->binder); 
    9191         
    … …  
    122122                                ->enableJsonRpc() 
    123123                                ->enableRss() 
    124                                 ->runningInMode(stubMode::$DEV) 
     124                                ->runningInMode(stubMode::dev()) 
    125125                                ->configure($this->binder); 
    126126         
    … …  
    157157                                ->enableJsonRpc('interceptors-bar') 
    158158                                ->enableRss('interceptors-baz') 
    159                                 ->runningInMode(stubMode::$DEV) 
     159                                ->runningInMode(stubMode::dev()) 
    160160                                ->configure($this->binder); 
    161161         
    … …  
    189189    public function createUserDefined() 
    190190    { 
    191         $this->websiteBindingModule->runningInMode(stubMode::$DEV) 
     191        $this->websiteBindingModule->runningInMode(stubMode::dev()) 
    192192                                   ->configure($this->binder); 
    193193        $processorResolver = $this->binder->getInjector()->getInstance('stubProcessorResolver'); 
    … …  
    211211    { 
    212212        stubWebsiteBindingModule::create('foo', 'org::stubbles::test::FooProcessor', 'interceptors-foo', 'org::stubbles::test::FooPageFactory') 
    213                                 ->runningInMode(stubMode::$DEV) 
     213                                ->runningInMode(stubMode::dev()) 
    214214                                ->configure($this->binder); 
    215215        $processorResolver = $this->binder->getInjector()->getInstance('stubProcessorResolver'); 
    … …  
    239239        $this->assertTrue($this->binder->getInjector()->hasBinding('stubInterceptorInitializer')); 
    240240        $this->assertTrue($this->binder->getInjector()->hasBinding('stubWebsiteCacheFactory')); 
    241         $this->assertSame(stubMode::$PROD, $this->binder->getInjector()->getInstance('stubMode')); 
     241        $this->assertEquals(stubMode::prod(), $this->binder->getInjector()->getInstance('stubMode')); 
    242242        $this->assertType('stubInterceptorXJConfInitializer', $this->binder->getInjector()->getInstance('stubInterceptorInitializer')); 
    243243        $this->assertType('stubDefaultWebsiteCacheFactory', $this->binder->getInjector()->getInstance('stubWebsiteCacheFactory')); 
    … …  
    252252    { 
    253253        $this->binder->bind('stubCacheContainer')->toInstance($this->getMock('stubCacheContainer')); 
    254         $this->assertEquals($this->websiteBindingModule, $this->websiteBindingModule->runningInMode(stubMode::$DEV)); 
     254        $devMode = stubMode::dev(); 
     255        $this->assertEquals($this->websiteBindingModule, $this->websiteBindingModule->runningInMode($devMode)); 
    255256        $this->websiteBindingModule->configure($this->binder); 
    256257        $this->assertTrue($this->binder->getInjector()->hasBinding('stubMode')); 
    257258        $this->assertTrue($this->binder->getInjector()->hasBinding('stubInterceptorInitializer')); 
    258259        $this->assertFalse($this->binder->getInjector()->hasBinding('stubWebsiteCacheFactory')); 
    259         $this->assertSame(stubMode::$DEV, $this->binder->getInjector()->getInstance('stubMode')); 
     260        $this->assertSame($devMode, $this->binder->getInjector()->getInstance('stubMode')); 
    260261        $this->assertType('stubInterceptorXJConfInitializer', $this->binder->getInjector()->getInstance('stubInterceptorInitializer')); 
    261         $this->assertSame(stubMode::$DEV, stubMode::$CURRENT); 
    262262    } 
    263263 
    … …  
    270270    { 
    271271        $this->binder->bind('stubCacheContainer')->toInstance($this->getMock('stubCacheContainer')); 
    272         $this->binder->bind('stubMode')->toInstance(stubMode::$STAGE); 
     272        $stageMode = stubMode::stage(); 
     273        $this->binder->bind('stubMode')->toInstance($stageMode); 
    273274        $this->websiteBindingModule->configure($this->binder); 
    274275        $this->assertTrue($this->binder->getInjector()->hasBinding('stubMode')); 
    275276        $this->assertTrue($this->binder->getInjector()->hasBinding('stubInterceptorInitializer')); 
    276277        $this->assertFalse($this->binder->getInjector()->hasBinding('stubWebsiteCacheFactory')); 
    277         $this->assertSame(stubMode::$STAGE, $this->binder->getInjector()->getInstance('stubMode')); 
     278        $this->assertSame($stageMode, $this->binder->getInjector()->getInstance('stubMode')); 
    278279        $this->assertType('stubInterceptorXJConfInitializer', $this->binder->getInjector()->getInstance('stubInterceptorInitializer')); 
    279280    } 
    … …  
    293294        $this->assertTrue($this->binder->getInjector()->hasBinding('stubInterceptorInitializer')); 
    294295        $this->assertTrue($this->binder->getInjector()->hasBinding('stubWebsiteCacheFactory')); 
    295         $this->assertSame(stubMode::$PROD, $this->binder->getInjector()->getInstance('stubMode')); 
     296        $this->assertEquals(stubMode::prod(), $this->binder->getInjector()->getInstance('stubMode')); 
    296297        $this->assertSame($mockInterceptorInitializer, $this->binder->getInjector()->getInstance('stubInterceptorInitializer')); 
    297298        $this->assertType('stubDefaultWebsiteCacheFactory', $this->binder->getInjector()->getInstance('stubWebsiteCacheFactory')); 

  • framework/trunk/src/test/php/net/stubbles/websites/stubFrontControllerTestCase.php

    r2081 r2082  
    273273    public function modeHandlingRegistersErrorAndExceptionHandler() 
    274274    { 
    275         $mockErrorHandler     = $this->getMock('stubErrorHandler'); 
    276         $mockExceptionHandler = $this->getMock('stubExceptionHandler'); 
    277         stubMode::$TEST->setErrorHandler($mockErrorHandler, 'handle', stubMode::HANDLER_INSTANCE); 
    278         stubMode::$TEST->setExceptionHandler($mockExceptionHandler, 'handleException', stubMode::HANDLER_INSTANCE); 
    279         $this->assertSame($this->frontController, $this->frontController->setMode(stubMode::$TEST)); 
    280         $mockErrorHandler->expects($this->once()) 
    281                          ->method('handle') 
    282                          ->will($this->returnValue(true)); 
    283         trigger_error('message', E_USER_NOTICE); 
    284         // can not test exception handler, would require an uncatched exception 
    285         restore_error_handler(); 
    286         restore_exception_handler(); 
     275        $mockMode = $this->getMock('stubMode', array(), array('FOO', array(), array(), false)); 
     276        $mockMode->expects($this->once()) 
     277                 ->method('registerErrorHandler'); 
     278        $mockMode->expects($this->once()) 
     279                 ->method('registerExceptionHandler'); 
     280        $this->assertSame($this->frontController, $this->frontController->setMode($mockMode)); 
    287281    } 
    288282} 

  • framework/trunk/src/test/php/net/stubbles/websites/xml/generator/stubModeXMLGeneratorTestCase.php

    r1944 r2082  
    33 * Tests for net::stubbles::websites::xml::generator::stubModeXMLGenerator. 
    44 * 
    5  * @author      Frank Kleine <mikey@stubbles.net> 
    65 * @package     stubbles 
    76 * @subpackage  websites_xml_generator_test 
    … …  
    6867    public function prodMode() 
    6968    { 
    70         stubMode::setCurrent(stubMode::$PROD); 
     69        stubMode::setCurrent(stubMode::prod()); 
    7170        $this->assertTrue($this->modeXMLGenerator->isCachable()); 
    7271        $this->modeXMLGenerator->generate($this->xmlStreamWriter, $this->mockXMLSerializer); 
    … …  
    8685    public function devMode() 
    8786    { 
    88         stubMode::setCurrent(stubMode::$DEV); 
     87        stubMode::setCurrent(stubMode::dev()); 
    8988        $this->assertFalse($this->modeXMLGenerator->isCachable()); 
    9089        $this->modeXMLGenerator->generate($this->xmlStreamWriter, $this->mockXMLSerializer); 

  • framework/trunk/src/test/php/net/stubbles/websites/xml/skin/stubSkinGeneratorProviderTestCase.php

    r2060 r2082  
    7373    public function prodModeDeliversCachingSkinGenerator() 
    7474    { 
    75         $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::$PROD, $this->injector); 
     75        $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::prod(), $this->injector); 
    7676        $this->assertSame($this->mockCachingSkinGenerator, $skinGeneratorProvider->get()); 
    7777    } 
    … …  
    8484    public function testModeDeliversCachingSkinGenerator() 
    8585    { 
    86         $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::$TEST, $this->injector); 
     86        $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::test(), $this->injector); 
    8787        $this->assertSame($this->mockCachingSkinGenerator, $skinGeneratorProvider->get()); 
    8888    } 
    … …  
    9595    public function stageModeDeliversDefaultSkinGenerator() 
    9696    { 
    97         $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::$STAGE, $this->injector); 
     97        $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::stage(), $this->injector); 
    9898        $this->assertSame($this->mockDefaultSkinGenerator, $skinGeneratorProvider->get()); 
    9999    } 
    … …  
    106106    public function devModeDeliversDefaultSkinGenerator() 
    107107    { 
    108         $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::$DEV, $this->injector); 
     108        $skinGeneratorProvider = new stubSkinGeneratorProvider(stubMode::dev(), $this->injector); 
    109109        $this->assertSame($this->mockDefaultSkinGenerator, $skinGeneratorProvider->get()); 
    110110    }