VendorSoftware
/
symfony


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524
							<?php

/*
 * This file is part of the symfony package.
 *
 * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Tests\Components\DomCrawler;

use Symfony\Components\DomCrawler\Crawler;

class CrawlerTest extends \PHPUnit_Framework_TestCase
{
  public function testConstructor()
  {
    $crawler = new Crawler();
    $this->assertEquals(0, count($crawler), '__construct() returns an empty crawler');

    $crawler = new Crawler(new \DOMNode());
    $this->assertEquals(1, count($crawler), '__construct() takes a node as a first argument');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::add
   */
  public function testAdd()
  {
    $crawler = new Crawler();
    $crawler->add($this->createDomDocument());
    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->add() adds nodes from a \DOMDocument');

    $crawler = new Crawler();
    $crawler->add($this->createNodeList());
    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->add() adds nodes from a \DOMNodeList');

    foreach ($this->createNodeList() as $node)
    {
      $list[] = $node;
    }
    $crawler = new Crawler();
    $crawler->add($list);
    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->add() adds nodes from an array of nodes');

    $crawler = new Crawler();
    $crawler->add($this->createNodeList()->item(0));
    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->add() adds nodes from an \DOMNode');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addHtmlContent
   */
  public function testAddHtmlContent()
  {
    $crawler = new Crawler();
    $crawler->addHtmlContent('<html><div class="foo"></html>', 'UTF-8');

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addHtmlContent() adds nodes from an HTML string');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addXmlContent
   */
  public function testAddXmlContent()
  {
    $crawler = new Crawler();
    $crawler->addXmlContent('<html><div class="foo"></div></html>', 'UTF-8');

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addXmlContent() adds nodes from an XML string');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addDocument
   */
  public function testAddDocument()
  {
    $crawler = new Crawler();
    $crawler->addDocument($this->createDomDocument());

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addDocument() adds nodes from a \DOMDocument');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addNodeList
   */
  public function testAddNodeList()
  {
    $crawler = new Crawler();
    $crawler->addNodeList($this->createNodeList());

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addNodeList() adds nodes from a \DOMNodeList');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addNodes
   */
  public function testAddNodes()
  {
    foreach ($this->createNodeList() as $node)
    {
      $list[] = $node;
    }

    $crawler = new Crawler();
    $crawler->addNodes($list);

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addNodes() adds nodes from an array of nodes');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::addNode
   */
  public function testAddNode()
  {
    $crawler = new Crawler();
    $crawler->addNode($this->createNodeList()->item(0));

    $this->assertEquals('foo', $crawler->filter('div')->attr('class'), '->addNode() adds nodes from an \DOMNode');
  }

  public function testClear()
  {
    $crawler = new Crawler(new \DOMNode());
    $crawler->clear();
    $this->assertEquals(0, count($crawler), '->clear() removes all the nodes from the crawler');
  }

  public function testIsEmpty()
  {
    $crawler = new Crawler(new \DOMNode());
    $this->assertFalse($crawler->isEmpty(), '->isEmpty() returns false if the crawler node list is not empty');
    $crawler->clear();
    $this->assertTrue($crawler->isEmpty(), '->isEmpty() returns true if the crawler node list is empty');
  }

  public function testEq()
  {
    $crawler = $this->createTestCrawler()->filter('li');
    $this->assertNotSame($crawler, $crawler->eq(0), '->eq() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->eq() returns a new instance of a crawler');

    $this->assertEquals('Two', $crawler->eq(1)->text(), '->eq() returns the nth node of the list');
    $this->assertTrue($crawler->eq(100)->isEmpty(), '->eq() returns an empty crawler if the nth node does not exist');
  }

  public function testEach()
  {
    $data = $this->createTestCrawler()->filter('ul.first li')->each(function ($node, $i)
    {
      return $i.'-'.$node->nodeValue;
    });

    $this->assertEquals(array('0-One', '1-Two', '2-Three'), $data, '->each() executes an anonymous function on each node of the list');
  }

  public function testReduce()
  {
    $crawler = $this->createTestCrawler()->filter('ul.first li');
    $nodes = $crawler->reduce(function ($node, $i)
    {
      return $i == 1 ? false : true;
    });
    $this->assertNotSame($nodes, $crawler, '->reduce() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $nodes, '->reduce() returns a new instance of a crawler');

    $this->assertEquals(2, count($nodes), '->reduce() filters the nodes in the list');
  }

  public function testAttr()
  {
    $this->assertEquals('first', $this->createTestCrawler()->filter('li')->attr('class'), '->attr() returns the attribute of the first element of the node list');

    try
    {
      $this->createTestCrawler()->filter('ol')->attr('class');
      $this->fail('->attr() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->attr() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testText()
  {
    $this->assertEquals('One', $this->createTestCrawler()->filter('li')->text(), '->text() returns the node value of the first element of the node list');

    try
    {
      $this->createTestCrawler()->filter('ol')->text();
      $this->fail('->text() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->text() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testExtract()
  {
    $crawler = $this->createTestCrawler()->filter('ul.first li');

    $this->assertEquals(array('One', 'Two', 'Three'), $crawler->extract('_text'), '->extract() returns an array of extracted data from the node list');
    $this->assertEquals(array(array('One', 'first'), array('Two', ''), array('Three', '')), $crawler->extract(array('_text', 'class')), '->extract() returns an array of extracted data from the node list');

    $this->assertEquals(array(), $this->createTestCrawler()->filter('lo')->extract('_text'), '->extract() returns an empty array if the node list is empty');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::filterXPath
   */
  public function testFilterXPath()
  {
    $crawler = $this->createTestCrawler();
    $this->assertNotSame($crawler, $crawler->filterXPath('//li'), '->filterXPath() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->filterXPath() returns a new instance of a crawler');

    $crawler = $this->createTestCrawler()->filter('ul');

    $this->assertEquals(6, $crawler->filterXPath('//li')->count(), '->filterXPath() filters the node list with the XPath expression');
  }

  /**
   * @covers Symfony\Components\DomCrawler\Crawler::filter
   */
  public function testFilter()
  {
    $crawler = $this->createTestCrawler();
    $this->assertNotSame($crawler, $crawler->filter('li'), '->filter() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->filter() returns a new instance of a crawler');

    $crawler = $this->createTestCrawler()->filter('ul');

    $this->assertEquals(6, $crawler->filter('li')->count(), '->filter() filters the node list with the CSS selector');
  }

  public function testSelectLink()
  {
    $crawler = $this->createTestCrawler();
    $this->assertNotSame($crawler, $crawler->selectLink('Foo'), '->selectLink() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->selectLink() returns a new instance of a crawler');

    $this->assertEquals(1, $crawler->selectLink('Fabien\'s Foo')->count(), '->selectLink() selects links by the node values');
    $this->assertEquals(1, $crawler->selectLink('Fabien\'s Bar')->count(), '->selectLink() selects links by the alt attribute of a clickable image');

    $this->assertEquals(2, $crawler->selectLink('Fabien"s Foo')->count(), '->selectLink() selects links by the node values');
    $this->assertEquals(2, $crawler->selectLink('Fabien"s Bar')->count(), '->selectLink() selects links by the alt attribute of a clickable image');

    $this->assertEquals(1, $crawler->selectLink('\' Fabien"s Foo')->count(), '->selectLink() selects links by the node values');
    $this->assertEquals(1, $crawler->selectLink('\' Fabien"s Bar')->count(), '->selectLink() selects links by the alt attribute of a clickable image');

    $this->assertEquals(4, $crawler->selectLink('Foo')->count(), '->selectLink() selects links by the node values');
    $this->assertEquals(4, $crawler->selectLink('Bar')->count(), '->selectLink() selects links by the node values');
  }

  public function testSelectButton()
  {
    $crawler = $this->createTestCrawler();
    $this->assertNotSame($crawler, $crawler->selectButton('FooValue'), '->selectButton() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->selectButton() returns a new instance of a crawler');

    $this->assertEquals(1, $crawler->selectButton('FooValue')->count(), '->selectButton() selects buttons');
    $this->assertEquals(1, $crawler->selectButton('FooName')->count(), '->selectButton() selects buttons');
    $this->assertEquals(1, $crawler->selectButton('FooId')->count(), '->selectButton() selects buttons');

    $this->assertEquals(1, $crawler->selectButton('BarValue')->count(), '->selectButton() selects buttons');
    $this->assertEquals(1, $crawler->selectButton('BarName')->count(), '->selectButton() selects buttons');
    $this->assertEquals(1, $crawler->selectButton('BarId')->count(), '->selectButton() selects buttons');
  }

  public function testLink()
  {
    $crawler = $this->createTestCrawler()->selectLink('Foo');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Link', $crawler->link(), '->link() returns a Link instance');

    $this->assertEquals('/foo', $crawler->link()->getUri(), '->link() returns a Link instance');
    $this->assertEquals('post', $crawler->link('post')->getMethod(), '->link() takes a method as its argument');

    $crawler = $this->createTestCrawler('http://example.com/bar/')->selectLink('Foo');
    $this->assertEquals('http://example.com/bar/foo', $crawler->link()->getUri(), '->link() returns a Link instance');

    $crawler = $this->createTestCrawler('http://example.com/bar')->selectLink('Foo');
    $this->assertEquals('http://example.com/foo', $crawler->link()->getUri(), '->form() linketurns a Link instance');

    try
    {
      $this->createTestCrawler()->filter('ol')->link();
      $this->fail('->link() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->link() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testLinks()
  {
    $crawler = $this->createTestCrawler()->selectLink('Foo');
    $this->assertType('array', $crawler->links(), '->links() returns an array');

    $this->assertEquals(4, count($crawler->links()), '->links() returns an array');
    $links = $crawler->links();
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Link', $links[0], '->links() returns an array of Link instances');

    $this->assertEquals(array(), $this->createTestCrawler()->filter('ol')->links(), '->links() returns an empty array if the node selection is empty');
  }

  public function testForm()
  {
    $crawler = $this->createTestCrawler()->selectButton('FooValue');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Form', $crawler->form(), '->form() returns a Form instance');

    $this->assertEquals('/foo?FooName=FooValue', $crawler->form()->getUri(), '->form() returns a Form instance');
    $this->assertEquals(array('FooName' => 'FooBar'), $crawler->form(array('FooName' => 'FooBar'))->getValues(), '->form() takes an array of values to submit as its first argument');

    $crawler = $this->createTestCrawler('http://example.com/bar/')->selectButton('FooValue');
    $this->assertEquals('http://example.com/bar/foo?FooName=FooValue', $crawler->form()->getUri(), '->form() returns a Form instance');

    $crawler = $this->createTestCrawler('http://example.com/bar')->selectButton('FooValue');
    $this->assertEquals('http://example.com/foo?FooName=FooValue', $crawler->form()->getUri(), '->form() returns a Form instance');

    try
    {
      $this->createTestCrawler()->filter('ol')->form();
      $this->fail('->form() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->form() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testLast()
  {
    $crawler = $this->createTestCrawler()->filter('ul.first li');
    $this->assertNotSame($crawler, $crawler->last(), '->last() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->last() returns a new instance of a crawler');

    $this->assertEquals('Three', $crawler->last()->text());
  }

  public function testFirst()
  {
    $crawler = $this->createTestCrawler()->filter('li');
    $this->assertNotSame($crawler, $crawler->first(), '->first() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->first() returns a new instance of a crawler');

    $this->assertEquals('One', $crawler->first()->text());
  }

  public function testSiblings()
  {
    $crawler = $this->createTestCrawler()->filter('li')->eq(1);
    $this->assertNotSame($crawler, $crawler->siblings(), '->siblings() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->siblings() returns a new instance of a crawler');

    $nodes = $crawler->siblings();
    $this->assertEquals(2, $nodes->count());
    $this->assertEquals('One', $nodes->eq(0)->text());
    $this->assertEquals('Three', $nodes->eq(1)->text());

    $nodes = $this->createTestCrawler()->filter('li')->eq(0)->siblings();
    $this->assertEquals(2, $nodes->count());
    $this->assertEquals('Two', $nodes->eq(0)->text());
    $this->assertEquals('Three', $nodes->eq(1)->text());

    try
    {
      $this->createTestCrawler()->filter('ol')->siblings();
      $this->fail('->siblings() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->siblings() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testNextAll()
  {
    $crawler = $this->createTestCrawler()->filter('li')->eq(1);
    $this->assertNotSame($crawler, $crawler->nextAll(), '->nextAll() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->nextAll() returns a new instance of a crawler');

    $nodes = $crawler->nextAll();
    $this->assertEquals(1, $nodes->count());
    $this->assertEquals('Three', $nodes->eq(0)->text());

    try
    {
      $this->createTestCrawler()->filter('ol')->nextAll();
      $this->fail('->nextAll() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->nextAll() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testPreviousAll()
  {
    $crawler = $this->createTestCrawler()->filter('li')->eq(2);
    $this->assertNotSame($crawler, $crawler->previousAll(), '->previousAll() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->previousAll() returns a new instance of a crawler');

    $nodes = $crawler->previousAll();
    $this->assertEquals(2, $nodes->count());
    $this->assertEquals('Two', $nodes->eq(0)->text());

    try
    {
      $this->createTestCrawler()->filter('ol')->previousAll();
      $this->fail('->previousAll() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->previousAll() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testChildren()
  {
    $crawler = $this->createTestCrawler()->filter('ul');
    $this->assertNotSame($crawler, $crawler->children(), '->children() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->children() returns a new instance of a crawler');

    $nodes = $crawler->children();
    $this->assertEquals(3, $nodes->count());
    $this->assertEquals('One', $nodes->eq(0)->text());
    $this->assertEquals('Two', $nodes->eq(1)->text());
    $this->assertEquals('Three', $nodes->eq(2)->text());

    try
    {
      $this->createTestCrawler()->filter('ol')->children();
      $this->fail('->children() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->children() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function testParents()
  {
    $crawler = $this->createTestCrawler()->filter('li:first-child');
    $this->assertNotSame($crawler, $crawler->parents(), '->parents() returns a new instance of a crawler');
    $this->assertInstanceOf('Symfony\\Components\\DomCrawler\\Crawler', $crawler, '->parents() returns a new instance of a crawler');

    $nodes = $crawler->parents();
    $this->assertEquals(3, $nodes->count());

    $nodes = $this->createTestCrawler()->filter('html')->parents();
    $this->assertEquals(0, $nodes->count());

    try
    {
      $this->createTestCrawler()->filter('ol')->parents();
      $this->fail('->parents() throws an \InvalidArgumentException if the node list is empty');
    }
    catch (\InvalidArgumentException $e)
    {
      $this->assertTrue(true, '->parents() throws an \InvalidArgumentException if the node list is empty');
    }
  }

  public function createTestCrawler($uri = null)
  {
    $dom = new \DOMDocument();
    $dom->loadHTML('
      <html>
        <body>
          <a href="foo">Foo</a>
          <a href="/foo">   Fabien\'s Foo   </a>
          <a href="/foo">Fabien"s Foo</a>
          <a href="/foo">\' Fabien"s Foo</a>

          <a href="/bar"><img alt="Bar"/></a>
          <a href="/bar"><img alt="   Fabien\'s Bar   "/></a>
          <a href="/bar"><img alt="Fabien&quot;s Bar"/></a>
          <a href="/bar"><img alt="\' Fabien&quot;s Bar"/></a>

          <form action="foo">
            <input type="submit" value="FooValue" name="FooName" id="FooId" />
            <input type="button" value="BarValue" name="BarName" id="BarId" />
            <button value="ButtonValue" name="ButtonName" id="ButtonId" />
          </form>

          <ul class="first">
            <li class="first">One</li>
            <li>Two</li>
            <li>Three</li>
          </ul>
          <ul>
            <li>One Bis</li>
            <li>Two Bis</li>
            <li>Three Bis</li>
          </ul>
        </body>
      </html>
    ');

    return new Crawler($dom, $uri);
  }

  protected function createDomDocument()
  {
    $dom = new \DOMDocument();
    $dom->loadXML('<html><div class="foo"></div></html>');

    return $dom;
  }

  protected function createNodeList()
  {
    $dom = new \DOMDocument();
    $dom->loadXML('<html><div class="foo"></div></html>');
    $domxpath = new \DOMXPath($dom);

    return $domxpath->query('//div');
  }
}