interface/modules/zend_modules/library/Zend/Test/PHPUnit/Controller/AbstractHttpControllerTestCase.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9 namespace Zend\Test\PHPUnit\Controller;
  10
  11 use PHPUnit_Framework_ExpectationFailedException;
  12 use Zend\Dom;
  13
  14 abstract class AbstractHttpControllerTestCase extends AbstractControllerTestCase
  15 {
  16     /**
  17      * HTTP controller must not use the console request
  18      * @var bool
  19      */
  20     protected $useConsoleRequest = false;
  21
  22     /**
  23      * XPath namespaces
  24      * @var array
  25      */
  26     protected $xpathNamespaces = array();
  27
  28     /**
  29      * Get response header by key
  30      *
  31      * @param  string $header
  32      * @return \Zend\Http\Header\HeaderInterface|false
  33      */
  34     protected function getResponseHeader($header)
  35     {
  36         $response       = $this->getResponse();
  37         $headers        = $response->getHeaders();
  38         $responseHeader = $headers->get($header, false);
  39         return $responseHeader;
  40     }
  41
  42     /**
  43      * Assert response header exists
  44      *
  45      * @param  string $header
  46      */
  47     public function assertHasResponseHeader($header)
  48     {
  49         $responseHeader = $this->getResponseHeader($header);
  50         if (false === $responseHeader) {
  51             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
  52                 'Failed asserting response header "%s" found',
  53                 $header
  54             ));
  55         }
  56         $this->assertNotEquals(false, $responseHeader);
  57     }
  58
  59     /**
  60      * Assert response header does not exist
  61      *
  62      * @param  string $header
  63      */
  64     public function assertNotHasResponseHeader($header)
  65     {
  66         $responseHeader = $this->getResponseHeader($header);
  67         if (false !== $responseHeader) {
  68             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
  69                 'Failed asserting response header "%s" WAS NOT found',
  70                 $header
  71             ));
  72         }
  73         $this->assertFalse($responseHeader);
  74     }
  75
  76     /**
  77      * Assert response header exists and contains the given string
  78      *
  79      * @param  string $header
  80      * @param  string $match
  81      */
  82     public function assertResponseHeaderContains($header, $match)
  83     {
  84         $responseHeader = $this->getResponseHeader($header);
  85         if (!$responseHeader) {
  86             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
  87                 'Failed asserting response header, header "%s" do not exists',
  88                 $header
  89             ));
  90         }
  91         if ($match != $responseHeader->getFieldValue()) {
  92             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
  93                 'Failed asserting response header "%s" exists and contains "%s", actual content is "%s"',
  94                 $header,
  95                 $match,
  96                 $responseHeader->getFieldValue()
  97             ));
  98         }
  99         $this->assertEquals($match, $responseHeader->getFieldValue());
 100     }
 101
 102     /**
 103      * Assert response header exists and contains the given string
 104      *
 105      * @param  string $header
 106      * @param  string $match
 107      */
 108     public function assertNotResponseHeaderContains($header, $match)
 109     {
 110         $responseHeader = $this->getResponseHeader($header);
 111         if (!$responseHeader) {
 112             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 113                 'Failed asserting response header, header "%s" do not exists',
 114                 $header
 115             ));
 116         }
 117         if ($match == $responseHeader->getFieldValue()) {
 118             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 119                 'Failed asserting response header "%s" DOES NOT CONTAIN "%s"',
 120                 $header,
 121                 $match
 122             ));
 123         }
 124         $this->assertNotEquals($match, $responseHeader->getFieldValue());
 125     }
 126
 127     /**
 128      * Assert response header exists and matches the given pattern
 129      *
 130      * @param  string $header
 131      * @param  string $pattern
 132      */
 133     public function assertResponseHeaderRegex($header, $pattern)
 134     {
 135         $responseHeader = $this->getResponseHeader($header);
 136         if (!$responseHeader) {
 137             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 138                 'Failed asserting response header, header "%s" do not exists',
 139                 $header
 140             ));
 141         }
 142         if (!preg_match($pattern, $responseHeader->getFieldValue())) {
 143             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 144                 'Failed asserting response header "%s" exists and matches regex "%s", actual content is "%s"',
 145                 $header,
 146                 $pattern,
 147                 $responseHeader->getFieldValue()
 148             ));
 149         }
 150         $this->assertTrue((bool) preg_match($pattern, $responseHeader->getFieldValue()));
 151     }
 152
 153     /**
 154      * Assert response header does not exist and/or does not match the given regex
 155      *
 156      * @param  string $header
 157      * @param  string $pattern
 158      */
 159     public function assertNotResponseHeaderRegex($header, $pattern)
 160     {
 161         $responseHeader = $this->getResponseHeader($header);
 162         if (!$responseHeader) {
 163             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 164                 'Failed asserting response header, header "%s" do not exists',
 165                 $header
 166             ));
 167         }
 168         if (preg_match($pattern, $responseHeader->getFieldValue())) {
 169             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 170                 'Failed asserting response header "%s" DOES NOT MATCH regex "%s"',
 171                 $header,
 172                 $pattern
 173             ));
 174         }
 175         $this->assertFalse((bool) preg_match($pattern, $responseHeader->getFieldValue()));
 176     }
 177
 178     /**
 179      * Assert that response is a redirect
 180      */
 181     public function assertRedirect()
 182     {
 183         $responseHeader = $this->getResponseHeader('Location');
 184         if (false === $responseHeader) {
 185             throw new PHPUnit_Framework_ExpectationFailedException(
 186                 'Failed asserting response is a redirect'
 187             );
 188         }
 189         $this->assertNotEquals(false, $responseHeader);
 190     }
 191
 192     /**
 193      * Assert that response is NOT a redirect
 194      */
 195     public function assertNotRedirect()
 196     {
 197         $responseHeader = $this->getResponseHeader('Location');
 198         if (false !== $responseHeader) {
 199             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 200                 'Failed asserting response is NOT a redirect, actual redirection is "%s"',
 201                 $responseHeader->getFieldValue()
 202             ));
 203         }
 204         $this->assertFalse($responseHeader);
 205     }
 206
 207     /**
 208      * Assert that response redirects to given URL
 209      *
 210      * @param  string $url
 211      */
 212     public function assertRedirectTo($url)
 213     {
 214         $responseHeader = $this->getResponseHeader('Location');
 215         if (!$responseHeader) {
 216             throw new PHPUnit_Framework_ExpectationFailedException(
 217                 'Failed asserting response is a redirect'
 218             );
 219         }
 220         if ($url != $responseHeader->getFieldValue()) {
 221             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 222                 'Failed asserting response redirects to "%s", actual redirection is "%s"',
 223                 $url,
 224                 $responseHeader->getFieldValue()
 225             ));
 226         }
 227         $this->assertEquals($url, $responseHeader->getFieldValue());
 228     }
 229
 230     /**
 231      * Assert that response does not redirect to given URL
 232      *
 233      * @param  string $url
 234      */
 235     public function assertNotRedirectTo($url)
 236     {
 237         $responseHeader = $this->getResponseHeader('Location');
 238         if (!$responseHeader) {
 239             throw new PHPUnit_Framework_ExpectationFailedException(
 240                 'Failed asserting response is a redirect'
 241             );
 242         }
 243         if ($url == $responseHeader->getFieldValue()) {
 244             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 245                 'Failed asserting response redirects to "%s"',
 246                 $url
 247             ));
 248         }
 249         $this->assertNotEquals($url, $responseHeader->getFieldValue());
 250     }
 251
 252     /**
 253      * Assert that redirect location matches pattern
 254      *
 255      * @param  string $pattern
 256      */
 257     public function assertRedirectRegex($pattern)
 258     {
 259         $responseHeader = $this->getResponseHeader('Location');
 260         if (!$responseHeader) {
 261             throw new PHPUnit_Framework_ExpectationFailedException(
 262                 'Failed asserting response is a redirect'
 263             );
 264         }
 265         if (!preg_match($pattern, $responseHeader->getFieldValue())) {
 266             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 267                 'Failed asserting response redirects to URL MATCHING "%s", actual redirection is "%s"',
 268                 $pattern,
 269                 $responseHeader->getFieldValue()
 270             ));
 271         }
 272         $this->assertTrue((bool) preg_match($pattern, $responseHeader->getFieldValue()));
 273     }
 274
 275     /**
 276      * Assert that redirect location does not match pattern
 277      *
 278      * @param  string $pattern
 279      */
 280     public function assertNotRedirectRegex($pattern)
 281     {
 282         $responseHeader = $this->getResponseHeader('Location');
 283         if (!$responseHeader) {
 284             throw new PHPUnit_Framework_ExpectationFailedException(
 285                 'Failed asserting response is a redirect'
 286             );
 287         }
 288         if (preg_match($pattern, $responseHeader->getFieldValue())) {
 289             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 290                 'Failed asserting response DOES NOT redirect to URL MATCHING "%s"',
 291                 $pattern
 292             ));
 293         }
 294         $this->assertFalse((bool) preg_match($pattern, $responseHeader->getFieldValue()));
 295     }
 296
 297     /**
 298      * Register XPath namespaces
 299      *
 300      * @param   array $xpathNamespaces
 301      */
 302     public function registerXpathNamespaces(array $xpathNamespaces)
 303     {
 304         $this->xpathNamespaces = $xpathNamespaces;
 305     }
 306
 307     /**
 308      * Execute a DOM/XPath query
 309      *
 310      * @param  string $path
 311      * @param  bool $useXpath
 312      * @return array
 313      */
 314     private function query($path, $useXpath = false)
 315     {
 316         $response = $this->getResponse();
 317         $dom      = new Dom\Query($response->getContent());
 318         if ($useXpath) {
 319             $dom->registerXpathNamespaces($this->xpathNamespaces);
 320             return $dom->queryXpath($path);
 321         }
 322         return $dom->execute($path);
 323     }
 324
 325     /**
 326      * Execute a xpath query
 327      *
 328      * @param  string $path
 329      * @return array
 330      */
 331     private function xpathQuery($path)
 332     {
 333         return $this->query($path, true);
 334     }
 335
 336     /**
 337      * Count the dom query executed
 338      *
 339      * @param  string $path
 340      * @return int
 341      */
 342     private function queryCount($path)
 343     {
 344         return count($this->query($path, false));
 345     }
 346
 347     /**
 348      * Count the dom query executed
 349      *
 350      * @param  string $path
 351      * @return int
 352      */
 353     private function xpathQueryCount($path)
 354     {
 355         return count($this->xpathQuery($path));
 356     }
 357
 358     /**
 359      * Assert against DOM/XPath selection
 360      *
 361      * @param string $path
 362      * @param bool $useXpath
 363      */
 364     private function queryAssertion($path, $useXpath = false)
 365     {
 366         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 367         $match = $this->$method($path);
 368         if (!$match > 0) {
 369             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 370                 'Failed asserting node DENOTED BY %s EXISTS',
 371                 $path
 372             ));
 373         }
 374         $this->assertTrue($match > 0);
 375     }
 376
 377     /**
 378      * Assert against DOM selection
 379      *
 380      * @param  string $path CSS selector path
 381      */
 382     public function assertQuery($path)
 383     {
 384         $this->queryAssertion($path, false);
 385     }
 386
 387     /**
 388      * Assert against XPath selection
 389      *
 390      * @param  string $path XPath path
 391      */
 392     public function assertXpathQuery($path)
 393     {
 394         $this->queryAssertion($path, true);
 395     }
 396
 397     /**
 398      * Assert against DOM/XPath selection
 399      *
 400      * @param string $path CSS selector path
 401      * @param bool $useXpath
 402      */
 403     private function notQueryAssertion($path, $useXpath = false)
 404     {
 405         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 406         $match  = $this->$method($path);
 407         if ($match != 0) {
 408             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 409                 'Failed asserting node DENOTED BY %s DOES NOT EXIST',
 410                 $path
 411             ));
 412         }
 413         $this->assertEquals(0, $match);
 414     }
 415
 416     /**
 417      * Assert against DOM selection
 418      *
 419      * @param  string $path CSS selector path
 420      */
 421     public function assertNotQuery($path)
 422     {
 423         $this->notQueryAssertion($path, false);
 424     }
 425
 426     /**
 427      * Assert against XPath selection
 428      *
 429      * @param  string $path XPath path
 430      */
 431     public function assertNotXpathQuery($path)
 432     {
 433         $this->notQueryAssertion($path, true);
 434     }
 435
 436     /**
 437      * Assert against DOM/XPath selection; should contain exact number of nodes
 438      *
 439      * @param string $path CSS selector path
 440      * @param string $count Number of nodes that should match
 441      * @param bool $useXpath
 442      */
 443     private function queryCountAssertion($path, $count, $useXpath = false)
 444     {
 445         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 446         $match = $this->$method($path);
 447         if ($match != $count) {
 448             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 449                 'Failed asserting node DENOTED BY %s OCCURS EXACTLY %d times, actually occurs %d times',
 450                 $path,
 451                 $count,
 452                 $match
 453             ));
 454         }
 455         $this->assertEquals($match, $count);
 456     }
 457
 458     /**
 459      * Assert against DOM selection; should contain exact number of nodes
 460      *
 461      * @param  string $path CSS selector path
 462      * @param  string $count Number of nodes that should match
 463      */
 464     public function assertQueryCount($path, $count)
 465     {
 466         $this->queryCountAssertion($path, $count, false);
 467     }
 468
 469     /**
 470      * Assert against XPath selection; should contain exact number of nodes
 471      *
 472      * @param  string $path XPath path
 473      * @param  string $count Number of nodes that should match
 474      */
 475     public function assertXpathQueryCount($path, $count)
 476     {
 477         $this->queryCountAssertion($path, $count, true);
 478     }
 479
 480     /**
 481      * Assert against DOM/XPath selection; should NOT contain exact number of nodes
 482      *
 483      * @param  string $path CSS selector path
 484      * @param  string $count Number of nodes that should NOT match
 485      * @param bool $useXpath
 486      */
 487     private function notQueryCountAssertion($path, $count, $useXpath = false)
 488     {
 489         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 490         $match = $this->$method($path);
 491         if ($match == $count) {
 492             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 493                 'Failed asserting node DENOTED BY %s DOES NOT OCCUR EXACTLY %d times',
 494                 $path,
 495                 $count
 496             ));
 497         }
 498         $this->assertNotEquals($match, $count);
 499     }
 500
 501     /**
 502      * Assert against DOM selection; should NOT contain exact number of nodes
 503      *
 504      * @param  string $path CSS selector path
 505      * @param  string $count Number of nodes that should NOT match
 506      */
 507     public function assertNotQueryCount($path, $count)
 508     {
 509         $this->notQueryCountAssertion($path, $count, false);
 510     }
 511
 512     /**
 513      * Assert against XPath selection; should NOT contain exact number of nodes
 514      *
 515      * @param  string $path XPath path
 516      * @param  string $count Number of nodes that should NOT match
 517      */
 518     public function assertNotXpathQueryCount($path, $count)
 519     {
 520         $this->notQueryCountAssertion($path, $count, true);
 521     }
 522
 523     /**
 524      * Assert against DOM/XPath selection; should contain at least this number of nodes
 525      *
 526      * @param string $path CSS selector path
 527      * @param string $count Minimum number of nodes that should match
 528      * @param bool $useXpath
 529      */
 530     private function queryCountMinAssertion($path, $count, $useXpath = false)
 531     {
 532         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 533         $match = $this->$method($path);
 534         if ($match < $count) {
 535             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 536                 'Failed asserting node DENOTED BY %s OCCURS AT LEAST %d times, actually occurs %d times',
 537                 $path,
 538                 $count,
 539                 $match
 540             ));
 541         }
 542         $this->assertTrue($match >= $count);
 543     }
 544
 545     /**
 546      * Assert against DOM selection; should contain at least this number of nodes
 547      *
 548      * @param  string $path CSS selector path
 549      * @param  string $count Minimum number of nodes that should match
 550      */
 551     public function assertQueryCountMin($path, $count)
 552     {
 553         $this->queryCountMinAssertion($path, $count, false);
 554     }
 555
 556     /**
 557      * Assert against XPath selection; should contain at least this number of nodes
 558      *
 559      * @param  string $path XPath path
 560      * @param  string $count Minimum number of nodes that should match
 561      */
 562     public function assertXpathQueryCountMin($path, $count)
 563     {
 564         $this->queryCountMinAssertion($path, $count, true);
 565     }
 566
 567     /**
 568      * Assert against DOM/XPath selection; should contain no more than this number of nodes
 569      *
 570      * @param  string $path CSS selector path
 571      * @param  string $count Maximum number of nodes that should match
 572      * @param bool $useXpath
 573      */
 574     private function queryCountMaxAssertion($path, $count, $useXpath = false)
 575     {
 576         $method = $useXpath ? 'xpathQueryCount' : 'queryCount';
 577         $match = $this->$method($path);
 578         if ($match > $count) {
 579             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 580                 'Failed asserting node DENOTED BY %s OCCURS AT MOST %d times, actually occurs %d times',
 581                 $path,
 582                 $count,
 583                 $match
 584             ));
 585         }
 586         $this->assertTrue($match <= $count);
 587     }
 588
 589     /**
 590      * Assert against DOM selection; should contain no more than this number of nodes
 591      *
 592      * @param  string $path CSS selector path
 593      * @param  string $count Maximum number of nodes that should match
 594      */
 595     public function assertQueryCountMax($path, $count)
 596     {
 597         $this->queryCountMaxAssertion($path, $count, false);
 598     }
 599
 600     /**
 601      * Assert against XPath selection; should contain no more than this number of nodes
 602      *
 603      * @param  string $path XPath path
 604      * @param  string $count Maximum number of nodes that should match
 605      */
 606     public function assertXpathQueryCountMax($path, $count)
 607     {
 608         $this->queryCountMaxAssertion($path, $count, true);
 609     }
 610
 611     /**
 612      * Assert against DOM/XPath selection; node should contain content
 613      *
 614      * @param  string $path CSS selector path
 615      * @param  string $match content that should be contained in matched nodes
 616      * @param bool $useXpath
 617      */
 618     private function queryContentContainsAssertion($path, $match, $useXpath = false)
 619     {
 620         $result = $this->query($path, $useXpath);
 621         if ($result->count() == 0) {
 622             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 623                 'Failed asserting node DENOTED BY %s EXISTS',
 624                 $path
 625             ));
 626         }
 627         foreach ($result as $node) {
 628             if ($node->nodeValue == $match) {
 629                 $this->assertEquals($match, $node->nodeValue);
 630                 return;
 631             }
 632         }
 633         throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 634             'Failed asserting node denoted by %s CONTAINS content "%s"',
 635             $path,
 636             $match
 637         ));
 638     }
 639
 640     /**
 641      * Assert against DOM selection; node should contain content
 642      *
 643      * @param  string $path CSS selector path
 644      * @param  string $match content that should be contained in matched nodes
 645      */
 646     public function assertQueryContentContains($path, $match)
 647     {
 648         $this->queryContentContainsAssertion($path, $match, false);
 649     }
 650
 651     /**
 652      * Assert against XPath selection; node should contain content
 653      *
 654      * @param  string $path XPath path
 655      * @param  string $match content that should be contained in matched nodes
 656      */
 657     public function assertXpathQueryContentContains($path, $match)
 658     {
 659         $this->queryContentContainsAssertion($path, $match, true);
 660     }
 661
 662     /**
 663      * Assert against DOM/XPath selection; node should NOT contain content
 664      *
 665      * @param  string $path CSS selector path
 666      * @param  string $match content that should NOT be contained in matched nodes
 667      * @param bool $useXpath
 668      */
 669     private function notQueryContentContainsAssertion($path, $match, $useXpath = false)
 670     {
 671         $result = $this->query($path, $useXpath);
 672         if ($result->count() == 0) {
 673             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 674                 'Failed asserting node DENOTED BY %s EXISTS',
 675                 $path
 676             ));
 677         }
 678         foreach ($result as $node) {
 679             if ($node->nodeValue == $match) {
 680                 throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 681                     'Failed asserting node DENOTED BY %s DOES NOT CONTAIN content "%s"',
 682                     $path,
 683                     $match
 684                 ));
 685             }
 686         }
 687         $currentValue = $node->nodeValue;
 688         $this->assertNotEquals($currentValue, $match);
 689     }
 690
 691     /**
 692      * Assert against DOM selection; node should NOT contain content
 693      *
 694      * @param  string $path CSS selector path
 695      * @param  string $match content that should NOT be contained in matched nodes
 696      */
 697     public function assertNotQueryContentContains($path, $match)
 698     {
 699         $this->notQueryContentContainsAssertion($path, $match, false);
 700     }
 701
 702     /**
 703      * Assert against XPath selection; node should NOT contain content
 704      *
 705      * @param  string $path XPath path
 706      * @param  string $match content that should NOT be contained in matched nodes
 707      */
 708     public function assertNotXpathQueryContentContains($path, $match)
 709     {
 710         $this->notQueryContentContainsAssertion($path, $match, true);
 711     }
 712
 713     /**
 714      * Assert against DOM/XPath selection; node should match content
 715      *
 716      * @param  string $path CSS selector path
 717      * @param  string $pattern Pattern that should be contained in matched nodes
 718      * @param bool $useXpath
 719      */
 720     private function queryContentRegexAssertion($path, $pattern, $useXpath = false)
 721     {
 722         $result = $this->query($path, $useXpath);
 723         if ($result->count() == 0) {
 724             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 725                 'Failed asserting node DENOTED BY %s EXISTS',
 726                 $path
 727             ));
 728         }
 729         if (!preg_match($pattern, $result->current()->nodeValue)) {
 730             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 731                 'Failed asserting node denoted by %s CONTAINS content MATCHING "%s", actual content is "%s"',
 732                 $path,
 733                 $pattern,
 734                 $result->current()->nodeValue
 735             ));
 736         }
 737         $this->assertTrue((bool) preg_match($pattern, $result->current()->nodeValue));
 738     }
 739
 740     /**
 741      * Assert against DOM selection; node should match content
 742      *
 743      * @param  string $path CSS selector path
 744      * @param  string $pattern Pattern that should be contained in matched nodes
 745      */
 746     public function assertQueryContentRegex($path, $pattern)
 747     {
 748         $this->queryContentRegexAssertion($path, $pattern, false);
 749     }
 750
 751     /**
 752      * Assert against XPath selection; node should match content
 753      *
 754      * @param  string $path XPath path
 755      * @param  string $pattern Pattern that should be contained in matched nodes
 756      */
 757     public function assertXpathQueryContentRegex($path, $pattern)
 758     {
 759         $this->queryContentRegexAssertion($path, $pattern, true);
 760     }
 761
 762     /**
 763      * Assert against DOM/XPath selection; node should NOT match content
 764      *
 765      * @param string $path CSS selector path
 766      * @param string $pattern pattern that should NOT be contained in matched nodes
 767      * @param bool $useXpath
 768      */
 769     private function notQueryContentRegexAssertion($path, $pattern, $useXpath = false)
 770     {
 771         $result = $this->query($path, $useXpath);
 772         if ($result->count() == 0) {
 773             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 774                 'Failed asserting node DENOTED BY %s EXISTS',
 775                 $path
 776             ));
 777         }
 778         if (preg_match($pattern, $result->current()->nodeValue)) {
 779             throw new PHPUnit_Framework_ExpectationFailedException(sprintf(
 780                 'Failed asserting node DENOTED BY %s DOES NOT CONTAIN content MATCHING "%s"',
 781                 $path,
 782                 $pattern
 783             ));
 784         }
 785         $this->assertFalse((bool) preg_match($pattern, $result->current()->nodeValue));
 786     }
 787
 788     /**
 789      * Assert against DOM selection; node should NOT match content
 790      *
 791      * @param  string $path CSS selector path
 792      * @param  string $pattern pattern that should NOT be contained in matched nodes
 793      */
 794     public function assertNotQueryContentRegex($path, $pattern)
 795     {
 796         $this->notQueryContentRegexAssertion($path, $pattern, false);
 797     }
 798
 799     /**
 800      * Assert against XPath selection; node should NOT match content
 801      *
 802      * @param  string $path XPath path
 803      * @param  string $pattern pattern that should NOT be contained in matched nodes
 804      */
 805     public function assertNotXpathQueryContentRegex($path, $pattern)
 806     {
 807         $this->notQueryContentRegexAssertion($path, $pattern, true);
 808     }
 809 }