tests/RouterTest.php

   1 <?php
   2 namespace Shaarli;
   3
   4 /**
   5  * Unit tests for Router
   6  */
   7 class RouterTest extends \PHPUnit\Framework\TestCase
   8 {
   9     /**
  10      * Test findPage: login page output.
  11      * Valid: page should be return.
  12      *
  13      * @return void
  14      */
  15     public function testFindPageLoginValid()
  16     {
  17         $this->assertEquals(
  18             Router::$PAGE_LOGIN,
  19             Router::findPage('do=login', array(), false)
  20         );
  21
  22         $this->assertEquals(
  23             Router::$PAGE_LOGIN,
  24             Router::findPage('do=login', array(), 1)
  25         );
  26
  27         $this->assertEquals(
  28             Router::$PAGE_LOGIN,
  29             Router::findPage('do=login&stuff', array(), false)
  30         );
  31     }
  32
  33     /**
  34      * Test findPage: login page output.
  35      * Invalid: page shouldn't be return.
  36      *
  37      * @return void
  38      */
  39     public function testFindPageLoginInvalid()
  40     {
  41         $this->assertNotEquals(
  42             Router::$PAGE_LOGIN,
  43             Router::findPage('do=login', array(), true)
  44         );
  45
  46         $this->assertNotEquals(
  47             Router::$PAGE_LOGIN,
  48             Router::findPage('do=other', array(), false)
  49         );
  50     }
  51
  52     /**
  53      * Test findPage: picwall page output.
  54      * Valid: page should be return.
  55      *
  56      * @return void
  57      */
  58     public function testFindPagePicwallValid()
  59     {
  60         $this->assertEquals(
  61             Router::$PAGE_PICWALL,
  62             Router::findPage('do=picwall', array(), false)
  63         );
  64
  65         $this->assertEquals(
  66             Router::$PAGE_PICWALL,
  67             Router::findPage('do=picwall', array(), true)
  68         );
  69     }
  70
  71     /**
  72      * Test findPage: picwall page output.
  73      * Invalid: page shouldn't be return.
  74      *
  75      * @return void
  76      */
  77     public function testFindPagePicwallInvalid()
  78     {
  79         $this->assertEquals(
  80             Router::$PAGE_PICWALL,
  81             Router::findPage('do=picwall&stuff', array(), false)
  82         );
  83
  84         $this->assertNotEquals(
  85             Router::$PAGE_PICWALL,
  86             Router::findPage('do=other', array(), false)
  87         );
  88     }
  89
  90     /**
  91      * Test findPage: tagcloud page output.
  92      * Valid: page should be return.
  93      *
  94      * @return void
  95      */
  96     public function testFindPageTagcloudValid()
  97     {
  98         $this->assertEquals(
  99             Router::$PAGE_TAGCLOUD,
 100             Router::findPage('do=tagcloud', array(), false)
 101         );
 102
 103         $this->assertEquals(
 104             Router::$PAGE_TAGCLOUD,
 105             Router::findPage('do=tagcloud', array(), true)
 106         );
 107
 108         $this->assertEquals(
 109             Router::$PAGE_TAGCLOUD,
 110             Router::findPage('do=tagcloud&stuff', array(), false)
 111         );
 112     }
 113
 114     /**
 115      * Test findPage: tagcloud page output.
 116      * Invalid: page shouldn't be return.
 117      *
 118      * @return void
 119      */
 120     public function testFindPageTagcloudInvalid()
 121     {
 122         $this->assertNotEquals(
 123             Router::$PAGE_TAGCLOUD,
 124             Router::findPage('do=other', array(), false)
 125         );
 126     }
 127
 128     /**
 129      * Test findPage: linklist page output.
 130      * Valid: page should be return.
 131      *
 132      * @return void
 133      */
 134     public function testFindPageLinklistValid()
 135     {
 136         $this->assertEquals(
 137             Router::$PAGE_LINKLIST,
 138             Router::findPage('', array(), true)
 139         );
 140
 141         $this->assertEquals(
 142             Router::$PAGE_LINKLIST,
 143             Router::findPage('whatever', array(), true)
 144         );
 145
 146         $this->assertEquals(
 147             Router::$PAGE_LINKLIST,
 148             Router::findPage('whatever', array(), false)
 149         );
 150
 151         $this->assertEquals(
 152             Router::$PAGE_LINKLIST,
 153             Router::findPage('do=tools', array(), false)
 154         );
 155     }
 156
 157     /**
 158      * Test findPage: tools page output.
 159      * Valid: page should be return.
 160      *
 161      * @return void
 162      */
 163     public function testFindPageToolsValid()
 164     {
 165         $this->assertEquals(
 166             Router::$PAGE_TOOLS,
 167             Router::findPage('do=tools', array(), true)
 168         );
 169
 170         $this->assertEquals(
 171             Router::$PAGE_TOOLS,
 172             Router::findPage('do=tools&stuff', array(), true)
 173         );
 174     }
 175
 176     /**
 177      * Test findPage: tools page output.
 178      * Invalid: page shouldn't be return.
 179      *
 180      * @return void
 181      */
 182     public function testFindPageToolsInvalid()
 183     {
 184         $this->assertNotEquals(
 185             Router::$PAGE_TOOLS,
 186             Router::findPage('do=tools', array(), 1)
 187         );
 188
 189         $this->assertNotEquals(
 190             Router::$PAGE_TOOLS,
 191             Router::findPage('do=tools', array(), false)
 192         );
 193
 194         $this->assertNotEquals(
 195             Router::$PAGE_TOOLS,
 196             Router::findPage('do=other', array(), true)
 197         );
 198     }
 199
 200     /**
 201      * Test findPage: changepasswd page output.
 202      * Valid: page should be return.
 203      *
 204      * @return void
 205      */
 206     public function testFindPageChangepasswdValid()
 207     {
 208         $this->assertEquals(
 209             Router::$PAGE_CHANGEPASSWORD,
 210             Router::findPage('do=changepasswd', array(), true)
 211         );
 212         $this->assertEquals(
 213             Router::$PAGE_CHANGEPASSWORD,
 214             Router::findPage('do=changepasswd&stuff', array(), true)
 215         );
 216     }
 217
 218     /**
 219      * Test findPage: changepasswd page output.
 220      * Invalid: page shouldn't be return.
 221      *
 222      * @return void
 223      */
 224     public function testFindPageChangepasswdInvalid()
 225     {
 226         $this->assertNotEquals(
 227             Router::$PAGE_CHANGEPASSWORD,
 228             Router::findPage('do=changepasswd', array(), 1)
 229         );
 230
 231         $this->assertNotEquals(
 232             Router::$PAGE_CHANGEPASSWORD,
 233             Router::findPage('do=changepasswd', array(), false)
 234         );
 235
 236         $this->assertNotEquals(
 237             Router::$PAGE_CHANGEPASSWORD,
 238             Router::findPage('do=other', array(), true)
 239         );
 240     }
 241     /**
 242      * Test findPage: configure page output.
 243      * Valid: page should be return.
 244      *
 245      * @return void
 246      */
 247     public function testFindPageConfigureValid()
 248     {
 249         $this->assertEquals(
 250             Router::$PAGE_CONFIGURE,
 251             Router::findPage('do=configure', array(), true)
 252         );
 253
 254         $this->assertEquals(
 255             Router::$PAGE_CONFIGURE,
 256             Router::findPage('do=configure&stuff', array(), true)
 257         );
 258     }
 259
 260     /**
 261      * Test findPage: configure page output.
 262      * Invalid: page shouldn't be return.
 263      *
 264      * @return void
 265      */
 266     public function testFindPageConfigureInvalid()
 267     {
 268         $this->assertNotEquals(
 269             Router::$PAGE_CONFIGURE,
 270             Router::findPage('do=configure', array(), 1)
 271         );
 272
 273         $this->assertNotEquals(
 274             Router::$PAGE_CONFIGURE,
 275             Router::findPage('do=configure', array(), false)
 276         );
 277
 278         $this->assertNotEquals(
 279             Router::$PAGE_CONFIGURE,
 280             Router::findPage('do=other', array(), true)
 281         );
 282     }
 283
 284     /**
 285      * Test findPage: changetag page output.
 286      * Valid: page should be return.
 287      *
 288      * @return void
 289      */
 290     public function testFindPageChangetagValid()
 291     {
 292         $this->assertEquals(
 293             Router::$PAGE_CHANGETAG,
 294             Router::findPage('do=changetag', array(), true)
 295         );
 296
 297         $this->assertEquals(
 298             Router::$PAGE_CHANGETAG,
 299             Router::findPage('do=changetag&stuff', array(), true)
 300         );
 301     }
 302
 303     /**
 304      * Test findPage: changetag page output.
 305      * Invalid: page shouldn't be return.
 306      *
 307      * @return void
 308      */
 309     public function testFindPageChangetagInvalid()
 310     {
 311         $this->assertNotEquals(
 312             Router::$PAGE_CHANGETAG,
 313             Router::findPage('do=changetag', array(), 1)
 314         );
 315
 316         $this->assertNotEquals(
 317             Router::$PAGE_CHANGETAG,
 318             Router::findPage('do=changetag', array(), false)
 319         );
 320
 321         $this->assertNotEquals(
 322             Router::$PAGE_CHANGETAG,
 323             Router::findPage('do=other', array(), true)
 324         );
 325     }
 326
 327     /**
 328      * Test findPage: addlink page output.
 329      * Valid: page should be return.
 330      *
 331      * @return void
 332      */
 333     public function testFindPageAddlinkValid()
 334     {
 335         $this->assertEquals(
 336             Router::$PAGE_ADDLINK,
 337             Router::findPage('do=addlink', array(), true)
 338         );
 339
 340         $this->assertEquals(
 341             Router::$PAGE_ADDLINK,
 342             Router::findPage('do=addlink&stuff', array(), true)
 343         );
 344     }
 345
 346     /**
 347      * Test findPage: addlink page output.
 348      * Invalid: page shouldn't be return.
 349      *
 350      * @return void
 351      */
 352     public function testFindPageAddlinkInvalid()
 353     {
 354         $this->assertNotEquals(
 355             Router::$PAGE_ADDLINK,
 356             Router::findPage('do=addlink', array(), 1)
 357         );
 358
 359         $this->assertNotEquals(
 360             Router::$PAGE_ADDLINK,
 361             Router::findPage('do=addlink', array(), false)
 362         );
 363
 364         $this->assertNotEquals(
 365             Router::$PAGE_ADDLINK,
 366             Router::findPage('do=other', array(), true)
 367         );
 368     }
 369
 370     /**
 371      * Test findPage: export page output.
 372      * Valid: page should be return.
 373      *
 374      * @return void
 375      */
 376     public function testFindPageExportValid()
 377     {
 378         $this->assertEquals(
 379             Router::$PAGE_EXPORT,
 380             Router::findPage('do=export', array(), true)
 381         );
 382
 383         $this->assertEquals(
 384             Router::$PAGE_EXPORT,
 385             Router::findPage('do=export&stuff', array(), true)
 386         );
 387     }
 388
 389     /**
 390      * Test findPage: export page output.
 391      * Invalid: page shouldn't be return.
 392      *
 393      * @return void
 394      */
 395     public function testFindPageExportInvalid()
 396     {
 397         $this->assertNotEquals(
 398             Router::$PAGE_EXPORT,
 399             Router::findPage('do=export', array(), 1)
 400         );
 401
 402         $this->assertNotEquals(
 403             Router::$PAGE_EXPORT,
 404             Router::findPage('do=export', array(), false)
 405         );
 406
 407         $this->assertNotEquals(
 408             Router::$PAGE_EXPORT,
 409             Router::findPage('do=other', array(), true)
 410         );
 411     }
 412
 413     /**
 414      * Test findPage: import page output.
 415      * Valid: page should be return.
 416      *
 417      * @return void
 418      */
 419     public function testFindPageImportValid()
 420     {
 421         $this->assertEquals(
 422             Router::$PAGE_IMPORT,
 423             Router::findPage('do=import', array(), true)
 424         );
 425
 426         $this->assertEquals(
 427             Router::$PAGE_IMPORT,
 428             Router::findPage('do=import&stuff', array(), true)
 429         );
 430     }
 431
 432     /**
 433      * Test findPage: import page output.
 434      * Invalid: page shouldn't be return.
 435      *
 436      * @return void
 437      */
 438     public function testFindPageImportInvalid()
 439     {
 440         $this->assertNotEquals(
 441             Router::$PAGE_IMPORT,
 442             Router::findPage('do=import', array(), 1)
 443         );
 444
 445         $this->assertNotEquals(
 446             Router::$PAGE_IMPORT,
 447             Router::findPage('do=import', array(), false)
 448         );
 449
 450         $this->assertNotEquals(
 451             Router::$PAGE_IMPORT,
 452             Router::findPage('do=other', array(), true)
 453         );
 454     }
 455
 456     /**
 457      * Test findPage: editlink page output.
 458      * Valid: page should be return.
 459      *
 460      * @return void
 461      */
 462     public function testFindPageEditlinkValid()
 463     {
 464         $this->assertEquals(
 465             Router::$PAGE_EDITLINK,
 466             Router::findPage('whatever', array('edit_link' => 1), true)
 467         );
 468
 469         $this->assertEquals(
 470             Router::$PAGE_EDITLINK,
 471             Router::findPage('', array('edit_link' => 1), true)
 472         );
 473
 474
 475         $this->assertEquals(
 476             Router::$PAGE_EDITLINK,
 477             Router::findPage('whatever', array('post' => 1), true)
 478         );
 479
 480         $this->assertEquals(
 481             Router::$PAGE_EDITLINK,
 482             Router::findPage('whatever', array('post' => 1, 'edit_link' => 1), true)
 483         );
 484     }
 485
 486     /**
 487      * Test findPage: editlink page output.
 488      * Invalid: page shouldn't be return.
 489      *
 490      * @return void
 491      */
 492     public function testFindPageEditlinkInvalid()
 493     {
 494         $this->assertNotEquals(
 495             Router::$PAGE_EDITLINK,
 496             Router::findPage('whatever', array('edit_link' => 1), false)
 497         );
 498
 499         $this->assertNotEquals(
 500             Router::$PAGE_EDITLINK,
 501             Router::findPage('whatever', array('edit_link' => 1), 1)
 502         );
 503
 504         $this->assertNotEquals(
 505             Router::$PAGE_EDITLINK,
 506             Router::findPage('whatever', array(), true)
 507         );
 508     }
 509 }