ÿØÿà JFIF ÿÛ „ ( %!1!%*+...983,7(-.-
PK 3]l#8 2 Symfony/Component/DomCrawler/Tests/CrawlerTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests;
use Symfony\Component\CssSelector\CssSelector;
use Symfony\Component\DomCrawler\Crawler;
class CrawlerTest extends \PHPUnit_Framework_TestCase
{
public function testConstructor()
{
$crawler = new Crawler();
$this->assertCount(0, $crawler, '__construct() returns an empty crawler');
$crawler = new Crawler(new \DOMNode());
$this->assertCount(1, $crawler, '__construct() takes a node as a first argument');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::add
*/
public function testAdd()
{
$crawler = new Crawler();
$crawler->add($this->createDomDocument());
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->add() adds nodes from a \DOMDocument');
$crawler = new Crawler();
$crawler->add($this->createNodeList());
$this->assertEquals('foo', $crawler->filterXPath('//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->filterXPath('//div')->attr('class'), '->add() adds nodes from an array of nodes');
$crawler = new Crawler();
$crawler->add($this->createNodeList()->item(0));
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->add() adds nodes from an \DOMNode');
$crawler = new Crawler();
$crawler->add('
Foo');
$this->assertEquals('Foo', $crawler->filterXPath('//body')->text(), '->add() adds nodes from a string');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testAddInvalidNode()
{
$crawler = new Crawler();
$crawler->add(1);
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContent()
{
$crawler = new Crawler();
$crawler->addHtmlContent('
', 'UTF-8');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addHtmlContent() adds nodes from an HTML string');
$crawler->addHtmlContent('', 'UTF-8');
$this->assertEquals('http://symfony.com', $crawler->filterXPath('//base')->attr('href'), '->addHtmlContent() adds nodes from an HTML string');
$this->assertEquals('http://symfony.com/contact', $crawler->filterXPath('//a')->link()->getUri(), '->addHtmlContent() adds nodes from an HTML string');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContentCharset()
{
$crawler = new Crawler();
$crawler->addHtmlContent('
Tiếng Việt', 'UTF-8');
$this->assertEquals('Tiếng Việt', $crawler->filterXPath('//div')->text());
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContentInvalidBaseTag()
{
$crawler = new Crawler(null, 'http://symfony.com');
$crawler->addHtmlContent('', 'UTF-8');
$this->assertEquals('http://symfony.com/contact', current($crawler->filterXPath('//a')->links())->getUri(), '->addHtmlContent() correctly handles a non-existent base tag href attribute');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContentUnsupportedCharset()
{
$crawler = new Crawler();
$crawler->addHtmlContent(file_get_contents(__DIR__.'/Fixtures/windows-1250.html'), 'Windows-1250');
$this->assertEquals('Žťčýů', $crawler->filterXPath('//p')->text());
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContentCharsetGbk()
{
$crawler = new Crawler();
//gbk encode of
中文
$crawler->addHtmlContent(base64_decode('PGh0bWw+PHA+1tDOxDwvcD48L2h0bWw+'), 'gbk');
$this->assertEquals('中文', $crawler->filterXPath('//p')->text());
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addHtmlContent
*/
public function testAddHtmlContentWithErrors()
{
$internalErrors = libxml_use_internal_errors(true);
$crawler = new Crawler();
$crawler->addHtmlContent(<<
EOF
, 'UTF-8');
$errors = libxml_get_errors();
$this->assertCount(1, $errors);
$this->assertEquals("Tag nav invalid\n", $errors[0]->message);
libxml_clear_errors();
libxml_use_internal_errors($internalErrors);
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addXmlContent
*/
public function testAddXmlContent()
{
$crawler = new Crawler();
$crawler->addXmlContent('', 'UTF-8');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addXmlContent() adds nodes from an XML string');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addXmlContent
*/
public function testAddXmlContentCharset()
{
$crawler = new Crawler();
$crawler->addXmlContent('
Tiếng Việt
', 'UTF-8');
$this->assertEquals('Tiếng Việt', $crawler->filterXPath('//div')->text());
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addXmlContent
*/
public function testAddXmlContentWithErrors()
{
$internalErrors = libxml_use_internal_errors(true);
$crawler = new Crawler();
$crawler->addXmlContent(<<
EOF
, 'UTF-8');
$this->assertTrue(count(libxml_get_errors()) > 1);
libxml_clear_errors();
libxml_use_internal_errors($internalErrors);
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addContent
*/
public function testAddContent()
{
$crawler = new Crawler();
$crawler->addContent('
', 'text/html; charset=UTF-8');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() adds nodes from an HTML string');
$crawler = new Crawler();
$crawler->addContent('
', 'text/html; charset=UTF-8; dir=RTL');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() adds nodes from an HTML string with extended content type');
$crawler = new Crawler();
$crawler->addContent('
');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() uses text/html as the default type');
$crawler = new Crawler();
$crawler->addContent('', 'text/xml; charset=UTF-8');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() adds nodes from an XML string');
$crawler = new Crawler();
$crawler->addContent('', 'text/xml');
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() adds nodes from an XML string');
$crawler = new Crawler();
$crawler->addContent('foo bar', 'text/plain');
$this->assertCount(0, $crawler, '->addContent() does nothing if the type is not (x|ht)ml');
$crawler = new Crawler();
$crawler->addContent('中文');
$this->assertEquals('中文', $crawler->filterXPath('//span')->text(), '->addContent() guess wrong charset');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addDocument
*/
public function testAddDocument()
{
$crawler = new Crawler();
$crawler->addDocument($this->createDomDocument());
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addDocument() adds nodes from a \DOMDocument');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addNodeList
*/
public function testAddNodeList()
{
$crawler = new Crawler();
$crawler->addNodeList($this->createNodeList());
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addNodeList() adds nodes from a \DOMNodeList');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addNodes
*/
public function testAddNodes()
{
foreach ($this->createNodeList() as $node) {
$list[] = $node;
}
$crawler = new Crawler();
$crawler->addNodes($list);
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addNodes() adds nodes from an array of nodes');
}
/**
* @covers Symfony\Component\DomCrawler\Crawler::addNode
*/
public function testAddNode()
{
$crawler = new Crawler();
$crawler->addNode($this->createNodeList()->item(0));
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addNode() adds nodes from an \DOMNode');
}
public function testClear()
{
$crawler = new Crawler(new \DOMNode());
$crawler->clear();
$this->assertCount(0, $crawler, '->clear() removes all the nodes from the crawler');
}
public function testEq()
{
$crawler = $this->createTestCrawler()->filterXPath('//li');
$this->assertNotSame($crawler, $crawler->eq(0), '->eq() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\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->assertCount(0, $crawler->eq(100), '->eq() returns an empty crawler if the nth node does not exist');
}
public function testEach()
{
$data = $this->createTestCrawler()->filterXPath('//ul[1]/li')->each(function ($node, $i) {
return $i.'-'.$node->text();
});
$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()->filterXPath('//ul[1]/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\\Component\\DomCrawler\\Crawler', $nodes, '->reduce() returns a new instance of a crawler');
$this->assertCount(2, $nodes, '->reduce() filters the nodes in the list');
}
public function testAttr()
{
$this->assertEquals('first', $this->createTestCrawler()->filterXPath('//li')->attr('class'), '->attr() returns the attribute of the first element of the node list');
try {
$this->createTestCrawler()->filterXPath('//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 testMissingAttrValueIsNull()
{
$crawler = new Crawler();
$crawler->addContent('', 'text/html; charset=UTF-8');
$div = $crawler->filterXPath('//div');
$this->assertEquals('sample value', $div->attr('non-empty-attr'), '->attr() reads non-empty attributes correctly');
$this->assertEquals('', $div->attr('empty-attr'), '->attr() reads empty attributes correctly');
$this->assertNull($div->attr('missing-attr'), '->attr() reads missing attributes correctly');
}
public function testText()
{
$this->assertEquals('One', $this->createTestCrawler()->filterXPath('//li')->text(), '->text() returns the node value of the first element of the node list');
try {
$this->createTestCrawler()->filterXPath('//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 testHtml()
{
$this->assertEquals('', $this->createTestCrawler()->filterXPath('//a[5]')->html());
$this->assertEquals(''
, trim($this->createTestCrawler()->filterXPath('//form[@id="FooFormId"]')->html()));
try {
$this->createTestCrawler()->filterXPath('//ol')->html();
$this->fail('->html() throws an \InvalidArgumentException if the node list is empty');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->html() throws an \InvalidArgumentException if the node list is empty');
}
}
public function testExtract()
{
$crawler = $this->createTestCrawler()->filterXPath('//ul[1]/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()->filterXPath('//ol')->extract('_text'), '->extract() returns an empty array if the node list is empty');
}
/**
* @covers Symfony\Component\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\\Component\\DomCrawler\\Crawler', $crawler, '->filterXPath() returns a new instance of a crawler');
$crawler = $this->createTestCrawler()->filterXPath('//ul');
$this->assertCount(6, $crawler->filterXPath('//li'), '->filterXPath() filters the node list with the XPath expression');
}
public function testFilterXPathWithDefaultNamespace()
{
$crawler = $this->createTestXmlCrawler()->filterXPath('//default:entry/default:id');
$this->assertCount(1, $crawler, '->filterXPath() automatically registers a namespace');
$this->assertSame('tag:youtube.com,2008:video:kgZRZmEc9j4', $crawler->text());
}
public function testFilterXPathWithCustomDefaultNamespace()
{
$crawler = $this->createTestXmlCrawler();
$crawler->setDefaultNamespacePrefix('x');
$crawler = $crawler->filterXPath('//x:entry/x:id');
$this->assertCount(1, $crawler, '->filterXPath() lets to override the default namespace prefix');
$this->assertSame('tag:youtube.com,2008:video:kgZRZmEc9j4', $crawler->text());
}
public function testFilterXPathWithNamespace()
{
$crawler = $this->createTestXmlCrawler()->filterXPath('//yt:accessControl');
$this->assertCount(2, $crawler, '->filterXPath() automatically registers a namespace');
}
public function testFilterXPathWithMultipleNamespaces()
{
$crawler = $this->createTestXmlCrawler()->filterXPath('//media:group/yt:aspectRatio');
$this->assertCount(1, $crawler, '->filterXPath() automatically registers multiple namespaces');
$this->assertSame('widescreen', $crawler->text());
}
public function testFilterXPathWithManuallyRegisteredNamespace()
{
$crawler = $this->createTestXmlCrawler();
$crawler->registerNamespace('m', 'http://search.yahoo.com/mrss/');
$crawler = $crawler->filterXPath('//m:group/yt:aspectRatio');
$this->assertCount(1, $crawler, '->filterXPath() uses manually registered namespace');
$this->assertSame('widescreen', $crawler->text());
}
public function testFilterXPathWithAnUrl()
{
$crawler = $this->createTestXmlCrawler();
$crawler = $crawler->filterXPath('//media:category[@scheme="http://gdata.youtube.com/schemas/2007/categories.cat"]');
$this->assertCount(1, $crawler);
$this->assertSame('Music', $crawler->text());
}
/**
* @covers Symfony\Component\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\\Component\\DomCrawler\\Crawler', $crawler, '->filter() returns a new instance of a crawler');
$crawler = $this->createTestCrawler()->filter('ul');
$this->assertCount(6, $crawler->filter('li'), '->filter() filters the node list with the CSS selector');
}
public function testFilterWithDefaultNamespace()
{
$crawler = $this->createTestXmlCrawler()->filter('default|entry default|id');
$this->assertCount(1, $crawler, '->filter() automatically registers namespaces');
$this->assertSame('tag:youtube.com,2008:video:kgZRZmEc9j4', $crawler->text());
}
public function testFilterWithNamespace()
{
CssSelector::disableHtmlExtension();
$crawler = $this->createTestXmlCrawler()->filter('yt|accessControl');
$this->assertCount(2, $crawler, '->filter() automatically registers namespaces');
}
public function testFilterWithMultipleNamespaces()
{
CssSelector::disableHtmlExtension();
$crawler = $this->createTestXmlCrawler()->filter('media|group yt|aspectRatio');
$this->assertCount(1, $crawler, '->filter() automatically registers namespaces');
$this->assertSame('widescreen', $crawler->text());
}
public function testFilterWithDefaultNamespaceOnly()
{
$crawler = new Crawler('
http://localhost/fooweekly0.52012-11-16http://localhost/barweekly0.52012-11-16
');
$this->assertEquals(2, $crawler->filter('url')->count());
}
public function testSelectLink()
{
$crawler = $this->createTestCrawler();
$this->assertNotSame($crawler, $crawler->selectLink('Foo'), '->selectLink() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Crawler', $crawler, '->selectLink() returns a new instance of a crawler');
$this->assertCount(1, $crawler->selectLink('Fabien\'s Foo'), '->selectLink() selects links by the node values');
$this->assertCount(1, $crawler->selectLink('Fabien\'s Bar'), '->selectLink() selects links by the alt attribute of a clickable image');
$this->assertCount(2, $crawler->selectLink('Fabien"s Foo'), '->selectLink() selects links by the node values');
$this->assertCount(2, $crawler->selectLink('Fabien"s Bar'), '->selectLink() selects links by the alt attribute of a clickable image');
$this->assertCount(1, $crawler->selectLink('\' Fabien"s Foo'), '->selectLink() selects links by the node values');
$this->assertCount(1, $crawler->selectLink('\' Fabien"s Bar'), '->selectLink() selects links by the alt attribute of a clickable image');
$this->assertCount(4, $crawler->selectLink('Foo'), '->selectLink() selects links by the node values');
$this->assertCount(4, $crawler->selectLink('Bar'), '->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\\Component\\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');
$this->assertEquals(1, $crawler->selectButton('FooBarValue')->count(), '->selectButton() selects buttons with form attribute too');
$this->assertEquals(1, $crawler->selectButton('FooBarName')->count(), '->selectButton() selects buttons with form attribute too');
}
public function testLink()
{
$crawler = $this->createTestCrawler('http://example.com/bar/')->selectLink('Foo');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Link', $crawler->link(), '->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('GetLink');
$this->assertEquals('http://example.com/bar?get=param', $crawler->link()->getUri(), '->link() returns a Link instance');
try {
$this->createTestCrawler()->filterXPath('//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('http://example.com/bar/')->selectLink('Foo');
$this->assertInternalType('array', $crawler->links(), '->links() returns an array');
$this->assertCount(4, $crawler->links(), '->links() returns an array');
$links = $crawler->links();
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Link', $links[0], '->links() returns an array of Link instances');
$this->assertEquals(array(), $this->createTestCrawler()->filterXPath('//ol')->links(), '->links() returns an empty array if the node selection is empty');
}
public function testForm()
{
$testCrawler = $this->createTestCrawler('http://example.com/bar/');
$crawler = $testCrawler->selectButton('FooValue');
$crawler2 = $testCrawler->selectButton('FooBarValue');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Form', $crawler->form(), '->form() returns a Form instance');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Form', $crawler2->form(), '->form() returns a Form instance');
$this->assertEquals($crawler->form()->getFormNode()->getAttribute('id'), $crawler2->form()->getFormNode()->getAttribute('id'), '->form() works on elements with form attribute');
$this->assertEquals(array('FooName' => 'FooBar', 'TextName' => 'TextValue', 'FooTextName' => 'FooTextValue'), $crawler->form(array('FooName' => 'FooBar'))->getValues(), '->form() takes an array of values to submit as its first argument');
$this->assertEquals(array('FooName' => 'FooValue', 'TextName' => 'TextValue', 'FooTextName' => 'FooTextValue'), $crawler->form()->getValues(), '->getValues() returns correct form values');
$this->assertEquals(array('FooBarName' => 'FooBarValue', 'TextName' => 'TextValue', 'FooTextName' => 'FooTextValue'), $crawler2->form()->getValues(), '->getValues() returns correct form values');
try {
$this->createTestCrawler()->filterXPath('//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()->filterXPath('//ul[1]/li');
$this->assertNotSame($crawler, $crawler->last(), '->last() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Crawler', $crawler, '->last() returns a new instance of a crawler');
$this->assertEquals('Three', $crawler->last()->text());
}
public function testFirst()
{
$crawler = $this->createTestCrawler()->filterXPath('//li');
$this->assertNotSame($crawler, $crawler->first(), '->first() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Crawler', $crawler, '->first() returns a new instance of a crawler');
$this->assertEquals('One', $crawler->first()->text());
}
public function testSiblings()
{
$crawler = $this->createTestCrawler()->filterXPath('//li')->eq(1);
$this->assertNotSame($crawler, $crawler->siblings(), '->siblings() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\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()->filterXPath('//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()->filterXPath('//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()->filterXPath('//li')->eq(1);
$this->assertNotSame($crawler, $crawler->nextAll(), '->nextAll() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\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()->filterXPath('//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()->filterXPath('//li')->eq(2);
$this->assertNotSame($crawler, $crawler->previousAll(), '->previousAll() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\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()->filterXPath('//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()->filterXPath('//ul');
$this->assertNotSame($crawler, $crawler->children(), '->children() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\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()->filterXPath('//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');
}
try {
$crawler = new Crawler('');
$crawler->filter('p')->children();
$this->assertTrue(true, '->children() does not trigger a notice if the node has no children');
} catch (\PHPUnit_Framework_Error_Notice $e) {
$this->fail('->children() does not trigger a notice if the node has no children');
}
}
public function testParents()
{
$crawler = $this->createTestCrawler()->filterXPath('//li[1]');
$this->assertNotSame($crawler, $crawler->parents(), '->parents() returns a new instance of a crawler');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Crawler', $crawler, '->parents() returns a new instance of a crawler');
$nodes = $crawler->parents();
$this->assertEquals(3, $nodes->count());
$nodes = $this->createTestCrawler()->filterXPath('//html')->parents();
$this->assertEquals(0, $nodes->count());
try {
$this->createTestCrawler()->filterXPath('//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 testBaseTag()
{
$crawler = new Crawler('');
$this->assertEquals('http://base.com/link', $crawler->filterXPath('//a')->link()->getUri());
$crawler = new Crawler('', 'https://domain.com');
$this->assertEquals('https://base.com/link', $crawler->filterXPath('//a')->link()->getUri(), ' tag can use a schema-less URL');
$crawler = new Crawler('', 'https://domain.com');
$this->assertEquals('https://domain.com/path/link', $crawler->filterXPath('//a')->link()->getUri(), ' tag can set a path');
}
public function createTestCrawler($uri = null)
{
$dom = new \DOMDocument();
$dom->loadHTML('
Foo Fabien\'s Foo Fabien"s Foo\' Fabien"s FooGetLink
One
Two
Three
One Bis
Two Bis
Three Bis
');
return new Crawler($dom, $uri);
}
protected function createTestXmlCrawler($uri = null)
{
$xml = '
tag:youtube.com,2008:video:kgZRZmEc9j4Chordates - CrashCourse Biology #24widescreenMusic';
return new Crawler($xml, $uri);
}
protected function createDomDocument()
{
$dom = new \DOMDocument();
$dom->loadXML('');
return $dom;
}
protected function createNodeList()
{
$dom = new \DOMDocument();
$dom->loadXML('');
$domxpath = new \DOMXPath($dom);
return $domxpath->query('//div');
}
}
PK 3]w۴ = Symfony/Component/DomCrawler/Tests/Fixtures/windows-1250.htmlnu [
PK 3]x 8 Symfony/Component/DomCrawler/Tests/Fixtures/no-extensionnu [ Test
PK 3]5| | > Symfony/Component/DomCrawler/Tests/Field/FileFormFieldTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
use Symfony\Component\DomCrawler\Field\FileFormField;
class FileFormFieldTest extends FormFieldTestCase
{
public function testInitialize()
{
$node = $this->createNode('input', '', array('type' => 'file'));
$field = new FileFormField($node);
$this->assertEquals(array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => UPLOAD_ERR_NO_FILE, 'size' => 0), $field->getValue(), '->initialize() sets the value of the field to no file uploaded');
$node = $this->createNode('textarea', '');
try {
$field = new FileFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is not an input field');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is not an input field');
}
$node = $this->createNode('input', '', array('type' => 'text'));
try {
$field = new FileFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is not a file input field');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is not a file input field');
}
}
/**
* @dataProvider getSetValueMethods
*/
public function testSetValue($method)
{
$node = $this->createNode('input', '', array('type' => 'file'));
$field = new FileFormField($node);
$field->$method(null);
$this->assertEquals(array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => UPLOAD_ERR_NO_FILE, 'size' => 0), $field->getValue(), "->$method() clears the uploaded file if the value is null");
$field->$method(__FILE__);
$value = $field->getValue();
$this->assertEquals(basename(__FILE__), $value['name'], "->$method() sets the name of the file field");
$this->assertEquals('', $value['type'], "->$method() sets the type of the file field");
$this->assertInternalType('string', $value['tmp_name'], "->$method() sets the tmp_name of the file field");
$this->assertFileExists($value['tmp_name'], "->$method() creates a copy of the file at the tmp_name path");
$this->assertEquals(0, $value['error'], "->$method() sets the error of the file field");
$this->assertEquals(filesize(__FILE__), $value['size'], "->$method() sets the size of the file field");
$origInfo = pathinfo(__FILE__);
$tmpInfo = pathinfo($value['tmp_name']);
$this->assertEquals(
$origInfo['extension'],
$tmpInfo['extension'],
"->$method() keeps the same file extension in the tmp_name copy"
);
$field->$method(__DIR__.'/../Fixtures/no-extension');
$value = $field->getValue();
$this->assertArrayNotHasKey(
'extension',
pathinfo($value['tmp_name']),
"->$method() does not add a file extension in the tmp_name copy"
);
}
public function getSetValueMethods()
{
return array(
array('setValue'),
array('upload'),
);
}
public function testSetErrorCode()
{
$node = $this->createNode('input', '', array('type' => 'file'));
$field = new FileFormField($node);
$field->setErrorCode(UPLOAD_ERR_FORM_SIZE);
$value = $field->getValue();
$this->assertEquals(UPLOAD_ERR_FORM_SIZE, $value['error'], '->setErrorCode() sets the file input field error code');
try {
$field->setErrorCode('foobar');
$this->fail('->setErrorCode() throws a \InvalidArgumentException if the error code is not valid');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setErrorCode() throws a \InvalidArgumentException if the error code is not valid');
}
}
public function testSetRawFilePath()
{
$node = $this->createNode('input', '', array('type' => 'file'));
$field = new FileFormField($node);
$field->setFilePath(__FILE__);
$this->assertEquals(__FILE__, $field->getValue());
}
}
PK 3]2$G > Symfony/Component/DomCrawler/Tests/Field/FormFieldTestCase.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
class FormFieldTestCase extends \PHPUnit_Framework_TestCase
{
protected function createNode($tag, $value, $attributes = array())
{
$document = new \DOMDocument();
$node = $document->createElement($tag, $value);
foreach ($attributes as $name => $value) {
$node->setAttribute($name, $value);
}
return $node;
}
}
PK 3]Ջ= = @ Symfony/Component/DomCrawler/Tests/Field/ChoiceFormFieldTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
use Symfony\Component\DomCrawler\Field\ChoiceFormField;
class ChoiceFormFieldTest extends FormFieldTestCase
{
public function testInitialize()
{
$node = $this->createNode('textarea', '');
try {
$field = new ChoiceFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is not an input or a select');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is not an input or a select');
}
$node = $this->createNode('input', '', array('type' => 'text'));
try {
$field = new ChoiceFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is an input with a type different from checkbox or radio');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is an input with a type different from checkbox or radio');
}
}
public function testGetType()
{
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$this->assertEquals('radio', $field->getType(), '->getType() returns radio for radio buttons');
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$this->assertEquals('checkbox', $field->getType(), '->getType() returns radio for a checkbox');
$node = $this->createNode('select', '');
$field = new ChoiceFormField($node);
$this->assertEquals('select', $field->getType(), '->getType() returns radio for a select');
}
public function testIsMultiple()
{
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$this->assertFalse($field->isMultiple(), '->isMultiple() returns false for radio buttons');
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$this->assertFalse($field->isMultiple(), '->isMultiple() returns false for checkboxes');
$node = $this->createNode('select', '');
$field = new ChoiceFormField($node);
$this->assertFalse($field->isMultiple(), '->isMultiple() returns false for selects without the multiple attribute');
$node = $this->createNode('select', '', array('multiple' => 'multiple'));
$field = new ChoiceFormField($node);
$this->assertTrue($field->isMultiple(), '->isMultiple() returns true for selects with the multiple attribute');
}
public function testSelects()
{
$node = $this->createSelectNode(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
$this->assertTrue($field->hasValue(), '->hasValue() returns true for selects');
$this->assertEquals('foo', $field->getValue(), '->getValue() returns the first option if none are selected');
$this->assertFalse($field->isMultiple(), '->isMultiple() returns false when no multiple attribute is defined');
$node = $this->createSelectNode(array('foo' => false, 'bar' => true));
$field = new ChoiceFormField($node);
$this->assertEquals('bar', $field->getValue(), '->getValue() returns the selected option');
$field->setValue('foo');
$this->assertEquals('foo', $field->getValue(), '->setValue() changes the selected option');
try {
$field->setValue('foobar');
$this->fail('->setValue() throws an \InvalidArgumentException if the value is not one of the selected options');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setValue() throws an \InvalidArgumentException if the value is not one of the selected options');
}
try {
$field->setValue(array('foobar'));
$this->fail('->setValue() throws an \InvalidArgumentException if the value is an array');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setValue() throws an \InvalidArgumentException if the value is an array');
}
}
public function testMultipleSelects()
{
$node = $this->createSelectNode(array('foo' => false, 'bar' => false), array('multiple' => 'multiple'));
$field = new ChoiceFormField($node);
$this->assertEquals(array(), $field->getValue(), '->setValue() returns an empty array if multiple is true and no option is selected');
$field->setValue('foo');
$this->assertEquals(array('foo'), $field->getValue(), '->setValue() returns an array of options if multiple is true');
$field->setValue('bar');
$this->assertEquals(array('bar'), $field->getValue(), '->setValue() returns an array of options if multiple is true');
$field->setValue(array('foo', 'bar'));
$this->assertEquals(array('foo', 'bar'), $field->getValue(), '->setValue() returns an array of options if multiple is true');
$node = $this->createSelectNode(array('foo' => true, 'bar' => true), array('multiple' => 'multiple'));
$field = new ChoiceFormField($node);
$this->assertEquals(array('foo', 'bar'), $field->getValue(), '->getValue() returns the selected options');
try {
$field->setValue(array('foobar'));
$this->fail('->setValue() throws an \InvalidArgumentException if the value is not one of the options');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setValue() throws an \InvalidArgumentException if the value is not one of the options');
}
}
public function testRadioButtons()
{
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'bar'));
$field->addChoice($node);
$this->assertFalse($field->hasValue(), '->hasValue() returns false when no radio button is selected');
$this->assertNull($field->getValue(), '->getValue() returns null if no radio button is selected');
$this->assertFalse($field->isMultiple(), '->isMultiple() returns false for radio buttons');
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'bar', 'checked' => 'checked'));
$field->addChoice($node);
$this->assertTrue($field->hasValue(), '->hasValue() returns true when a radio button is selected');
$this->assertEquals('bar', $field->getValue(), '->getValue() returns the value attribute of the selected radio button');
$field->setValue('foo');
$this->assertEquals('foo', $field->getValue(), '->setValue() changes the selected radio button');
try {
$field->setValue('foobar');
$this->fail('->setValue() throws an \InvalidArgumentException if the value is not one of the radio button values');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setValue() throws an \InvalidArgumentException if the value is not one of the radio button values');
}
}
public function testRadioButtonIsDisabled()
{
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'foo', 'disabled' => 'disabled'));
$field = new ChoiceFormField($node);
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'bar'));
$field->addChoice($node);
$field->select('foo');
$this->assertEquals('foo', $field->getValue(), '->getValue() returns the value attribute of the selected radio button');
$this->assertTrue($field->isDisabled());
$field->select('bar');
$this->assertEquals('bar', $field->getValue(), '->getValue() returns the value attribute of the selected radio button');
$this->assertFalse($field->isDisabled());
}
public function testCheckboxes()
{
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name'));
$field = new ChoiceFormField($node);
$this->assertFalse($field->hasValue(), '->hasValue() returns false when the checkbox is not checked');
$this->assertNull($field->getValue(), '->getValue() returns null if the checkbox is not checked');
$this->assertFalse($field->isMultiple(), '->hasValue() returns false for checkboxes');
try {
$field->addChoice(new \DOMNode());
$this->fail('->addChoice() throws a \LogicException for checkboxes');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException for checkboxes');
}
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'checked' => 'checked'));
$field = new ChoiceFormField($node);
$this->assertTrue($field->hasValue(), '->hasValue() returns true when the checkbox is checked');
$this->assertEquals('1', $field->getValue(), '->getValue() returns 1 if the checkbox is checked and has no value attribute');
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'checked' => 'checked', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$this->assertEquals('foo', $field->getValue(), '->getValue() returns the value attribute if the checkbox is checked');
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'checked' => 'checked', 'value' => 'foo'));
$field = new ChoiceFormField($node);
$field->setValue(false);
$this->assertNull($field->getValue(), '->setValue() unchecks the checkbox is value is false');
$field->setValue(true);
$this->assertEquals('foo', $field->getValue(), '->setValue() checks the checkbox is value is true');
try {
$field->setValue('bar');
$this->fail('->setValue() throws an \InvalidArgumentException if the value is not one from the value attribute');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->setValue() throws an \InvalidArgumentException if the value is not one from the value attribute');
}
}
public function testTick()
{
$node = $this->createSelectNode(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
try {
$field->tick();
$this->fail('->tick() throws a \LogicException for select boxes');
} catch (\LogicException $e) {
$this->assertTrue(true, '->tick() throws a \LogicException for select boxes');
}
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name'));
$field = new ChoiceFormField($node);
$field->tick();
$this->assertEquals(1, $field->getValue(), '->tick() ticks checkboxes');
}
public function testUntick()
{
$node = $this->createSelectNode(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
try {
$field->untick();
$this->fail('->untick() throws a \LogicException for select boxes');
} catch (\LogicException $e) {
$this->assertTrue(true, '->untick() throws a \LogicException for select boxes');
}
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'checked' => 'checked'));
$field = new ChoiceFormField($node);
$field->untick();
$this->assertNull($field->getValue(), '->untick() unticks checkboxes');
}
public function testSelect()
{
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'checked' => 'checked'));
$field = new ChoiceFormField($node);
$field->select(true);
$this->assertEquals(1, $field->getValue(), '->select() changes the value of the field');
$field->select(false);
$this->assertNull($field->getValue(), '->select() changes the value of the field');
$node = $this->createSelectNode(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
$field->select('foo');
$this->assertEquals('foo', $field->getValue(), '->select() changes the selected option');
}
public function testOptionWithNoValue()
{
$node = $this->createSelectNodeWithEmptyOption(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
$field->select('foo');
$this->assertEquals('foo', $field->getValue(), '->select() changes the selected option');
}
public function testDisableValidation()
{
$node = $this->createSelectNode(array('foo' => false, 'bar' => false));
$field = new ChoiceFormField($node);
$field->disableValidation();
$field->setValue('foobar');
$this->assertEquals('foobar', $field->getValue(), '->disableValidation() allows to set a value which is not in the selected options.');
$node = $this->createSelectNode(array('foo' => false, 'bar' => false), array('multiple' => 'multiple'));
$field = new ChoiceFormField($node);
$field->disableValidation();
$field->setValue(array('foobar'));
$this->assertEquals(array('foobar'), $field->getValue(), '->disableValidation() allows to set a value which is not in the selected options.');
}
protected function createSelectNode($options, $attributes = array())
{
$document = new \DOMDocument();
$node = $document->createElement('select');
foreach ($attributes as $name => $value) {
$node->setAttribute($name, $value);
}
$node->setAttribute('name', 'name');
foreach ($options as $value => $selected) {
$option = $document->createElement('option', $value);
$option->setAttribute('value', $value);
if ($selected) {
$option->setAttribute('selected', 'selected');
}
$node->appendChild($option);
}
return $node;
}
protected function createSelectNodeWithEmptyOption($options, $attributes = array())
{
$document = new \DOMDocument();
$node = $document->createElement('select');
foreach ($attributes as $name => $value) {
$node->setAttribute($name, $value);
}
$node->setAttribute('name', 'name');
foreach ($options as $value => $selected) {
$option = $document->createElement('option', $value);
if ($selected) {
$option->setAttribute('selected', 'selected');
}
$node->appendChild($option);
}
return $node;
}
}
PK 3]Q Q ? Symfony/Component/DomCrawler/Tests/Field/InputFormFieldTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
use Symfony\Component\DomCrawler\Field\InputFormField;
class InputFormFieldTest extends FormFieldTestCase
{
public function testInitialize()
{
$node = $this->createNode('input', '', array('type' => 'text', 'name' => 'name', 'value' => 'value'));
$field = new InputFormField($node);
$this->assertEquals('value', $field->getValue(), '->initialize() sets the value of the field to the value attribute value');
$node = $this->createNode('textarea', '');
try {
$field = new InputFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is not an input');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is not an input');
}
$node = $this->createNode('input', '', array('type' => 'checkbox'));
try {
$field = new InputFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is a checkbox');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is a checkbox');
}
$node = $this->createNode('input', '', array('type' => 'file'));
try {
$field = new InputFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is a file');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is a file');
}
}
}
PK 3]!
D : Symfony/Component/DomCrawler/Tests/Field/FormFieldTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
use Symfony\Component\DomCrawler\Field\InputFormField;
class FormFieldTest extends FormFieldTestCase
{
public function testGetName()
{
$node = $this->createNode('input', '', array('type' => 'text', 'name' => 'name', 'value' => 'value'));
$field = new InputFormField($node);
$this->assertEquals('name', $field->getName(), '->getName() returns the name of the field');
}
public function testGetSetHasValue()
{
$node = $this->createNode('input', '', array('type' => 'text', 'name' => 'name', 'value' => 'value'));
$field = new InputFormField($node);
$this->assertEquals('value', $field->getValue(), '->getValue() returns the value of the field');
$field->setValue('foo');
$this->assertEquals('foo', $field->getValue(), '->setValue() sets the value of the field');
$this->assertTrue($field->hasValue(), '->hasValue() always returns true');
}
}
PK 3]n B Symfony/Component/DomCrawler/Tests/Field/TextareaFormFieldTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests\Field;
use Symfony\Component\DomCrawler\Field\TextareaFormField;
class TextareaFormFieldTest extends FormFieldTestCase
{
public function testInitialize()
{
$node = $this->createNode('textarea', 'foo bar');
$field = new TextareaFormField($node);
$this->assertEquals('foo bar', $field->getValue(), '->initialize() sets the value of the field to the textarea node value');
$node = $this->createNode('input', '');
try {
$field = new TextareaFormField($node);
$this->fail('->initialize() throws a \LogicException if the node is not a textarea');
} catch (\LogicException $e) {
$this->assertTrue(true, '->initialize() throws a \LogicException if the node is not a textarea');
}
// Ensure that valid HTML can be used on a textarea.
$node = $this->createNode('textarea', 'foo bar
Baz
');
$field = new TextareaFormField($node);
$this->assertEquals('foo bar
Baz
', $field->getValue(), '->initialize() sets the value of the field to the textarea node value');
// Ensure that we don't do any DOM manipulation/validation by passing in
// "invalid" HTML.
$node = $this->createNode('textarea', 'foo bar
Baz');
$field = new TextareaFormField($node);
$this->assertEquals('foo bar
Baz', $field->getValue(), '->initialize() sets the value of the field to the textarea node value');
}
}
PK 3]mY / Symfony/Component/DomCrawler/Tests/LinkTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests;
use Symfony\Component\DomCrawler\Link;
class LinkTest extends \PHPUnit_Framework_TestCase
{
/**
* @expectedException \LogicException
*/
public function testConstructorWithANonATag()
{
$dom = new \DOMDocument();
$dom->loadHTML('
');
new Link($dom->getElementsByTagName('div')->item(0), 'http://www.example.com/');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testConstructorWithAnInvalidCurrentUri()
{
$dom = new \DOMDocument();
$dom->loadHTML('foo');
new Link($dom->getElementsByTagName('a')->item(0), 'example.com');
}
public function testGetNode()
{
$dom = new \DOMDocument();
$dom->loadHTML('foo');
$node = $dom->getElementsByTagName('a')->item(0);
$link = new Link($node, 'http://example.com/');
$this->assertEquals($node, $link->getNode(), '->getNode() returns the node associated with the link');
}
public function testGetMethod()
{
$dom = new \DOMDocument();
$dom->loadHTML('foo');
$node = $dom->getElementsByTagName('a')->item(0);
$link = new Link($node, 'http://example.com/');
$this->assertEquals('GET', $link->getMethod(), '->getMethod() returns the method of the link');
$link = new Link($node, 'http://example.com/', 'post');
$this->assertEquals('POST', $link->getMethod(), '->getMethod() returns the method of the link');
}
/**
* @dataProvider getGetUriTests
*/
public function testGetUri($url, $currentUri, $expected)
{
$dom = new \DOMDocument();
$dom->loadHTML(sprintf('foo', $url));
$link = new Link($dom->getElementsByTagName('a')->item(0), $currentUri);
$this->assertEquals($expected, $link->getUri());
}
/**
* @dataProvider getGetUriTests
*/
public function testGetUriOnArea($url, $currentUri, $expected)
{
$dom = new \DOMDocument();
$dom->loadHTML(sprintf('', $url));
$link = new Link($dom->getElementsByTagName('area')->item(0), $currentUri);
$this->assertEquals($expected, $link->getUri());
}
public function getGetUriTests()
{
return array(
array('/foo', 'http://localhost/bar/foo/', 'http://localhost/foo'),
array('/foo', 'http://localhost/bar/foo', 'http://localhost/foo'),
array('
/foo', 'http://localhost/bar/foo/', 'http://localhost/foo'),
array('/foo
', 'http://localhost/bar/foo', 'http://localhost/foo'),
array('foo', 'http://localhost/bar/foo/', 'http://localhost/bar/foo/foo'),
array('foo', 'http://localhost/bar/foo', 'http://localhost/bar/foo'),
array('', 'http://localhost/bar/', 'http://localhost/bar/'),
array('#', 'http://localhost/bar/', 'http://localhost/bar/#'),
array('#bar', 'http://localhost/bar/#foo', 'http://localhost/bar/#bar'),
array('?a=b', 'http://localhost/bar/', 'http://localhost/bar/?a=b'),
array('http://login.foo.com/foo', 'http://localhost/bar/', 'http://login.foo.com/foo'),
array('https://login.foo.com/foo', 'https://localhost/bar/', 'https://login.foo.com/foo'),
array('mailto:foo@bar.com', 'http://localhost/foo', 'mailto:foo@bar.com'),
// tests schema relative URL (issue #7169)
array('//login.foo.com/foo', 'http://localhost/bar/', 'http://login.foo.com/foo'),
array('//login.foo.com/foo', 'https://localhost/bar/', 'https://login.foo.com/foo'),
array('?foo=2', 'http://localhost?foo=1', 'http://localhost?foo=2'),
array('?foo=2', 'http://localhost/?foo=1', 'http://localhost/?foo=2'),
array('?foo=2', 'http://localhost/bar?foo=1', 'http://localhost/bar?foo=2'),
array('?foo=2', 'http://localhost/bar/?foo=1', 'http://localhost/bar/?foo=2'),
array('?bar=2', 'http://localhost?foo=1', 'http://localhost?bar=2'),
array('foo', 'http://login.foo.com/bar/baz?/query/string', 'http://login.foo.com/bar/foo'),
array('.', 'http://localhost/foo/bar/baz', 'http://localhost/foo/bar/'),
array('./', 'http://localhost/foo/bar/baz', 'http://localhost/foo/bar/'),
array('./foo', 'http://localhost/foo/bar/baz', 'http://localhost/foo/bar/foo'),
array('..', 'http://localhost/foo/bar/baz', 'http://localhost/foo/'),
array('../', 'http://localhost/foo/bar/baz', 'http://localhost/foo/'),
array('../foo', 'http://localhost/foo/bar/baz', 'http://localhost/foo/foo'),
array('../..', 'http://localhost/foo/bar/baz', 'http://localhost/'),
array('../../', 'http://localhost/foo/bar/baz', 'http://localhost/'),
array('../../foo', 'http://localhost/foo/bar/baz', 'http://localhost/foo'),
array('../../foo', 'http://localhost/bar/foo/', 'http://localhost/foo'),
array('../bar/../../foo', 'http://localhost/bar/foo/', 'http://localhost/foo'),
array('../bar/./../../foo', 'http://localhost/bar/foo/', 'http://localhost/foo'),
array('../../', 'http://localhost/', 'http://localhost/'),
array('../../', 'http://localhost', 'http://localhost/'),
array('/foo', 'file:///', 'file:///foo'),
array('/foo', 'file:///bar/baz', 'file:///foo'),
array('foo', 'file:///', 'file:///foo'),
array('foo', 'file:///bar/baz', 'file:///bar/foo'),
);
}
}
PK 3]3ʖ ʖ / Symfony/Component/DomCrawler/Tests/FormTest.phpnu [
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\DomCrawler\Tests;
use Symfony\Component\DomCrawler\Form;
use Symfony\Component\DomCrawler\FormFieldRegistry;
use Symfony\Component\DomCrawler\Field;
class FormTest extends \PHPUnit_Framework_TestCase
{
public static function setUpBeforeClass()
{
// Ensure that the private helper class FormFieldRegistry is loaded
class_exists('Symfony\\Component\\DomCrawler\\Form');
}
public function testConstructorThrowsExceptionIfTheNodeHasNoFormAncestor()
{
$dom = new \DOMDocument();
$dom->loadHTML('
');
$nodes = $dom->getElementsByTagName('input');
try {
$form = new Form($nodes->item(0), 'http://example.com');
$this->fail('__construct() throws a \\LogicException if the node has no form ancestor');
} catch (\LogicException $e) {
$this->assertTrue(true, '__construct() throws a \\LogicException if the node has no form ancestor');
}
try {
$form = new Form($nodes->item(1), 'http://example.com');
$this->fail('__construct() throws a \\LogicException if the input type is not submit, button, or image');
} catch (\LogicException $e) {
$this->assertTrue(true, '__construct() throws a \\LogicException if the input type is not submit, button, or image');
}
$nodes = $dom->getElementsByTagName('button');
try {
$form = new Form($nodes->item(0), 'http://example.com');
$this->fail('__construct() throws a \\LogicException if the node has no form ancestor');
} catch (\LogicException $e) {
$this->assertTrue(true, '__construct() throws a \\LogicException if the node has no form ancestor');
}
}
/**
* __construct() should throw \\LogicException if the form attribute is invalid
* @expectedException \LogicException
*/
public function testConstructorThrowsExceptionIfNoRelatedForm()
{
$dom = new \DOMDocument();
$dom->loadHTML('
');
$nodes = $dom->getElementsByTagName('input');
$form = new Form($nodes->item(0), 'http://example.com');
$form = new Form($nodes->item(1), 'http://example.com');
}
public function testConstructorHandlesFormAttribute()
{
$dom = $this->createTestHtml5Form();
$inputElements = $dom->getElementsByTagName('input');
$buttonElements = $dom->getElementsByTagName('button');
// Tests if submit buttons are correctly assigned to forms
$form1 = new Form($buttonElements->item(1), 'http://example.com');
$this->assertSame($dom->getElementsByTagName('form')->item(0), $form1->getFormNode(), 'HTML5-compliant form attribute handled incorrectly');
$form1 = new Form($inputElements->item(3), 'http://example.com');
$this->assertSame($dom->getElementsByTagName('form')->item(0), $form1->getFormNode(), 'HTML5-compliant form attribute handled incorrectly');
$form2 = new Form($buttonElements->item(0), 'http://example.com');
$this->assertSame($dom->getElementsByTagName('form')->item(1), $form2->getFormNode(), 'HTML5-compliant form attribute handled incorrectly');
}
public function testConstructorHandlesFormValues()
{
$dom = $this->createTestHtml5Form();
$inputElements = $dom->getElementsByTagName('input');
$buttonElements = $dom->getElementsByTagName('button');
$form1 = new Form($inputElements->item(3), 'http://example.com');
$form2 = new Form($buttonElements->item(0), 'http://example.com');
// Tests if form values are correctly assigned to forms
$values1 = array(
'apples' => array('1', '2'),
'form_name' => 'form-1',
'button_1' => 'Capture fields',
'outer_field' => 'success'
);
$values2 = array(
'oranges' => array('1', '2', '3'),
'form_name' => 'form_2',
'button_2' => '',
'app_frontend_form_type_contact_form_type' => array('contactType' => '', 'firstName' => 'John')
);
$this->assertEquals($values1, $form1->getPhpValues(), 'HTML5-compliant form attribute handled incorrectly');
$this->assertEquals($values2, $form2->getPhpValues(), 'HTML5-compliant form attribute handled incorrectly');
}
public function testMultiValuedFields()
{
$form = $this->createForm('
');
$this->assertEquals(
array_keys($form->all()),
array('foo[2]', 'foo[3]', 'bar[foo][0]', 'bar[foo][foobar]')
);
$this->assertEquals($form->get('foo[2]')->getValue(), 'foo');
$this->assertEquals($form->get('foo[3]')->getValue(), 'foo');
$this->assertEquals($form->get('bar[foo][0]')->getValue(), 'foo');
$this->assertEquals($form->get('bar[foo][foobar]')->getValue(), 'foo');
$form['foo[2]'] = 'bar';
$form['foo[3]'] = 'bar';
$this->assertEquals($form->get('foo[2]')->getValue(), 'bar');
$this->assertEquals($form->get('foo[3]')->getValue(), 'bar');
$form['bar'] = array('foo' => array('0' => 'bar', 'foobar' => 'foobar'));
$this->assertEquals($form->get('bar[foo][0]')->getValue(), 'bar');
$this->assertEquals($form->get('bar[foo][foobar]')->getValue(), 'foobar');
}
/**
* @dataProvider provideInitializeValues
*/
public function testConstructor($message, $form, $values)
{
$form = $this->createForm('');
$this->assertEquals(
$values,
array_map(function ($field) {
$class = get_class($field);
return array(substr($class, strrpos($class, '\\') + 1), $field->getValue());
},
$form->all()
),
'->getDefaultValues() '.$message
);
}
public function provideInitializeValues()
{
return array(
array(
'does not take into account input fields without a name attribute',
'
',
array(),
),
array(
'does not take into account input fields with an empty name attribute value',
'
',
array(),
),
array(
'takes into account disabled input fields',
'
',
array('foo' => array('InputFormField', 'foo')),
),
array(
'appends the submitted button value',
'',
array('bar' => array('InputFormField', 'bar')),
),
array(
'appends the submitted button value for Button element',
'',
array('bar' => array('InputFormField', 'bar')),
),
array(
'appends the submitted button value but not other submit buttons',
'
',
array('foobar' => array('InputFormField', 'foobar')),
),
array(
'turns an image input into x and y fields',
'',
array('bar.x' => array('InputFormField', '0'), 'bar.y' => array('InputFormField', '0')),
),
array(
'returns textareas',
'
',
array('foo' => array('TextareaFormField', 'foo')),
),
array(
'returns inputs',
'
',
array('foo' => array('InputFormField', 'foo')),
),
array(
'returns checkboxes',
'
',
array('foo' => array('ChoiceFormField', 'foo')),
),
array(
'returns not-checked checkboxes',
'
',
array('foo' => array('ChoiceFormField', false)),
),
array(
'returns radio buttons',
'
',
array('foo' => array('ChoiceFormField', 'bar')),
),
array(
'returns file inputs',
'
',
array('foo' => array('FileFormField', array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0))),
),
);
}
public function testGetFormNode()
{
$dom = new \DOMDocument();
$dom->loadHTML('');
$form = new Form($dom->getElementsByTagName('input')->item(0), 'http://example.com');
$this->assertSame($dom->getElementsByTagName('form')->item(0), $form->getFormNode(), '->getFormNode() returns the form node associated with this form');
}
public function testGetFormNodeFromNamedForm()
{
$dom = new \DOMDocument();
$dom->loadHTML('');
$form = new Form($dom->getElementsByTagName('form')->item(0), 'http://example.com');
$this->assertSame($dom->getElementsByTagName('form')->item(0), $form->getFormNode(), '->getFormNode() returns the form node associated with this form');
}
public function testGetMethod()
{
$form = $this->createForm('');
$this->assertEquals('GET', $form->getMethod(), '->getMethod() returns get if no method is defined');
$form = $this->createForm('');
$this->assertEquals('POST', $form->getMethod(), '->getMethod() returns the method attribute value of the form');
$form = $this->createForm('', 'put');
$this->assertEquals('PUT', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided');
$form = $this->createForm('', 'delete');
$this->assertEquals('DELETE', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided');
$form = $this->createForm('', 'patch');
$this->assertEquals('PATCH', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided');
}
public function testGetSetValue()
{
$form = $this->createForm('');
$this->assertEquals('foo', $form['foo']->getValue(), '->offsetGet() returns the value of a form field');
$form['foo'] = 'bar';
$this->assertEquals('bar', $form['foo']->getValue(), '->offsetSet() changes the value of a form field');
try {
$form['foobar'] = 'bar';
$this->fail('->offsetSet() throws an \InvalidArgumentException exception if the field does not exist');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->offsetSet() throws an \InvalidArgumentException exception if the field does not exist');
}
try {
$form['foobar'];
$this->fail('->offsetSet() throws an \InvalidArgumentException exception if the field does not exist');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->offsetSet() throws an \InvalidArgumentException exception if the field does not exist');
}
}
public function testSetValueOnMultiValuedFieldsWithMalformedName()
{
$form = $this->createForm('');
try {
$form['foo[bar'] = 'bar';
$this->fail('->offsetSet() throws an \InvalidArgumentException exception if the name is malformed.');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->offsetSet() throws an \InvalidArgumentException exception if the name is malformed.');
}
}
public function testDisableValidation()
{
$form = $this->createForm('');
$form->disableValidation();
$form['foo[bar]']->select('foo');
$form['foo[baz]']->select('bar');
$this->assertEquals('foo', $form['foo[bar]']->getValue(), '->disableValidation() disables validation of all ChoiceFormField.');
$this->assertEquals('bar', $form['foo[baz]']->getValue(), '->disableValidation() disables validation of all ChoiceFormField.');
}
public function testOffsetUnset()
{
$form = $this->createForm('');
unset($form['foo']);
$this->assertFalse(isset($form['foo']), '->offsetUnset() removes a field');
}
public function testOffsetExists()
{
$form = $this->createForm('');
$this->assertTrue(isset($form['foo']), '->offsetExists() return true if the field exists');
$this->assertFalse(isset($form['bar']), '->offsetExists() return false if the field does not exist');
}
public function testGetValues()
{
$form = $this->createForm('');
$this->assertEquals(array('foo[bar]' => 'foo', 'bar' => 'bar'), $form->getValues(), '->getValues() returns all form field values');
$form = $this->createForm('');
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include not-checked checkboxes');
$form = $this->createForm('');
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include file input fields');
$form = $this->createForm('');
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include disabled fields');
}
public function testSetValues()
{
$form = $this->createForm('');
$form->setValues(array('foo' => false, 'bar' => 'foo'));
$this->assertEquals(array('bar' => 'foo'), $form->getValues(), '->setValues() sets the values of fields');
}
public function testMultiselectSetValues()
{
$form = $this->createForm('');
$form->setValues(array('multi' => array("foo", "bar")));
$this->assertEquals(array('multi' => array('foo', 'bar')), $form->getValues(), '->setValue() sets the values of select');
}
public function testGetPhpValues()
{
$form = $this->createForm('');
$this->assertEquals(array('foo' => array('bar' => 'foo'), 'bar' => 'bar'), $form->getPhpValues(), '->getPhpValues() converts keys with [] to arrays');
$form = $this->createForm('');
$this->assertEquals(array('fo.o' => array('ba.r' => 'foo'), 'ba r' => 'bar'), $form->getPhpValues(), '->getPhpValues() preserves periods and spaces in names');
$form = $this->createForm('');
$this->assertEquals(array('fo.o' => array('ba.r' => array('foo', 'ba.z' => 'bar'))), $form->getPhpValues(), '->getPhpValues() preserves periods and spaces in names recursively');
}
public function testGetFiles()
{
$form = $this->createForm('');
$this->assertEquals(array(), $form->getFiles(), '->getFiles() returns an empty array if method is get');
$form = $this->createForm('');
$this->assertEquals(array('foo[bar]' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0)), $form->getFiles(), '->getFiles() only returns file fields for POST');
$form = $this->createForm('', 'put');
$this->assertEquals(array('foo[bar]' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0)), $form->getFiles(), '->getFiles() only returns file fields for PUT');
$form = $this->createForm('', 'delete');
$this->assertEquals(array('foo[bar]' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0)), $form->getFiles(), '->getFiles() only returns file fields for DELETE');
$form = $this->createForm('', 'patch');
$this->assertEquals(array('foo[bar]' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0)), $form->getFiles(), '->getFiles() only returns file fields for PATCH');
$form = $this->createForm('');
$this->assertEquals(array(), $form->getFiles(), '->getFiles() does not include disabled file fields');
}
public function testGetPhpFiles()
{
$form = $this->createForm('');
$this->assertEquals(array('foo' => array('bar' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0))), $form->getPhpFiles(), '->getPhpFiles() converts keys with [] to arrays');
$form = $this->createForm('');
$this->assertEquals(array('f.o o' => array('bar' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0))), $form->getPhpFiles(), '->getPhpFiles() preserves periods and spaces in names');
$form = $this->createForm('');
$this->assertEquals(array('f.o o' => array('bar' => array('ba.z' => array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0), array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0)))), $form->getPhpFiles(), '->getPhpFiles() preserves periods and spaces in names recursively');
}
/**
* @dataProvider provideGetUriValues
*/
public function testGetUri($message, $form, $values, $uri, $method = null)
{
$form = $this->createForm($form, $method);
$form->setValues($values);
$this->assertEquals('http://example.com'.$uri, $form->getUri(), '->getUri() '.$message);
}
public function testGetBaseUri()
{
$dom = new \DOMDocument();
$dom->loadHTML('');
$nodes = $dom->getElementsByTagName('input');
$form = new Form($nodes->item($nodes->length - 1), 'http://www.foo.com/');
$this->assertEquals('http://www.foo.com/foo.php', $form->getUri());
}
public function testGetUriWithAnchor()
{
$form = $this->createForm('', null, 'http://example.com/id/123');
$this->assertEquals('http://example.com/id/123#foo', $form->getUri());
}
public function testGetUriActionAbsolute()
{
$formHtml='';
$form = $this->createForm($formHtml);
$this->assertEquals('https://login.foo.com/login.php?login_attempt=1', $form->getUri(), '->getUri() returns absolute URIs set in the action form');
$form = $this->createForm($formHtml, null, 'https://login.foo.com');
$this->assertEquals('https://login.foo.com/login.php?login_attempt=1', $form->getUri(), '->getUri() returns absolute URIs set in the action form');
$form = $this->createForm($formHtml, null, 'https://login.foo.com/bar/');
$this->assertEquals('https://login.foo.com/login.php?login_attempt=1', $form->getUri(), '->getUri() returns absolute URIs set in the action form');
// The action URI haven't the same domain Host have an another domain as Host
$form = $this->createForm($formHtml, null, 'https://www.foo.com');
$this->assertEquals('https://login.foo.com/login.php?login_attempt=1', $form->getUri(), '->getUri() returns absolute URIs set in the action form');
$form = $this->createForm($formHtml, null, 'https://www.foo.com/bar/');
$this->assertEquals('https://login.foo.com/login.php?login_attempt=1', $form->getUri(), '->getUri() returns absolute URIs set in the action form');
}
public function testGetUriAbsolute()
{
$form = $this->createForm('', null, 'http://localhost/foo/');
$this->assertEquals('http://localhost/foo/foo', $form->getUri(), '->getUri() returns absolute URIs');
$form = $this->createForm('', null, 'http://localhost/foo/');
$this->assertEquals('http://localhost/foo', $form->getUri(), '->getUri() returns absolute URIs');
}
public function testGetUriWithOnlyQueryString()
{
$form = $this->createForm('', null, 'http://localhost/foo/bar');
$this->assertEquals('http://localhost/foo/bar?get=param', $form->getUri(), '->getUri() returns absolute URIs only if the host has been defined in the constructor');
}
public function testGetUriWithoutAction()
{
$form = $this->createForm('', null, 'http://localhost/foo/bar');
$this->assertEquals('http://localhost/foo/bar', $form->getUri(), '->getUri() returns path if no action defined');
}
public function provideGetUriValues()
{
return array(
array(
'returns the URI of the form',
'',
array(),
'/foo'
),
array(
'appends the form values if the method is get',
'',
array(),
'/foo?foo=foo'
),
array(
'appends the form values and merges the submitted values',
'',
array('foo' => 'bar'),
'/foo?foo=bar'
),
array(
'does not append values if the method is post',
'',
array(),
'/foo'
),
array(
'does not append values if the method is patch',
'',
array(),
'/foo',
'PUT'
),
array(
'does not append values if the method is delete',
'',
array(),
'/foo',
'DELETE'
),
array(
'does not append values if the method is put',
'',
array(),
'/foo',
'PATCH'
),
array(
'appends the form values to an existing query string',
'',
array(),
'/foo?bar=bar&foo=foo'
),
array(
'returns an empty URI if the action is empty',
'',
array(),
'/',
),
array(
'appends the form values even if the action is empty',
'',
array(),
'/?foo=foo',
),
array(
'chooses the path if the action attribute value is a sharp (#)',
'',
array(),
'/#',
),
);
}
public function testHas()
{
$form = $this->createForm('');
$this->assertFalse($form->has('foo'), '->has() returns false if a field is not in the form');
$this->assertTrue($form->has('bar'), '->has() returns true if a field is in the form');
}
public function testRemove()
{
$form = $this->createForm('');
$form->remove('bar');
$this->assertFalse($form->has('bar'), '->remove() removes a field');
}
public function testGet()
{
$form = $this->createForm('');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Field\\InputFormField', $form->get('bar'), '->get() returns the field object associated with the given name');
try {
$form->get('foo');
$this->fail('->get() throws an \InvalidArgumentException if the field does not exist');
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true, '->get() throws an \InvalidArgumentException if the field does not exist');
}
}
public function testAll()
{
$form = $this->createForm('');
$fields = $form->all();
$this->assertCount(1, $fields, '->all() return an array of form field objects');
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Field\\InputFormField', $fields['bar'], '->all() return an array of form field objects');
}
public function testSubmitWithoutAFormButton()
{
$dom = new \DOMDocument();
$dom->loadHTML('
');
$nodes = $dom->getElementsByTagName('form');
$form = new Form($nodes->item(0), 'http://example.com');
$this->assertSame($nodes->item(0), $form->getFormNode(), '->getFormNode() returns the form node associated with this form');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistryAddThrowAnExceptionWhenTheNameIsMalformed()
{
$registry = new FormFieldRegistry();
$registry->add($this->getFormFieldMock('[foo]'));
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistryRemoveThrowAnExceptionWhenTheNameIsMalformed()
{
$registry = new FormFieldRegistry();
$registry->remove('[foo]');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistryGetThrowAnExceptionWhenTheNameIsMalformed()
{
$registry = new FormFieldRegistry();
$registry->get('[foo]');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistryGetThrowAnExceptionWhenTheFieldDoesNotExist()
{
$registry = new FormFieldRegistry();
$registry->get('foo');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistrySetThrowAnExceptionWhenTheNameIsMalformed()
{
$registry = new FormFieldRegistry();
$registry->set('[foo]', null);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFormFieldRegistrySetThrowAnExceptionWhenTheFieldDoesNotExist()
{
$registry = new FormFieldRegistry();
$registry->set('foo', null);
}
public function testFormFieldRegistryHasReturnsTrueWhenTheFQNExists()
{
$registry = new FormFieldRegistry();
$registry->add($this->getFormFieldMock('foo[bar]'));
$this->assertTrue($registry->has('foo'));
$this->assertTrue($registry->has('foo[bar]'));
$this->assertFalse($registry->has('bar'));
$this->assertFalse($registry->has('foo[foo]'));
}
public function testFormRegistryFieldsCanBeRemoved()
{
$registry = new FormFieldRegistry();
$registry->add($this->getFormFieldMock('foo'));
$registry->remove('foo');
$this->assertFalse($registry->has('foo'));
}
public function testFormRegistrySupportsMultivaluedFields()
{
$registry = new FormFieldRegistry();
$registry->add($this->getFormFieldMock('foo[]'));
$registry->add($this->getFormFieldMock('foo[]'));
$registry->add($this->getFormFieldMock('bar[5]'));
$registry->add($this->getFormFieldMock('bar[]'));
$registry->add($this->getFormFieldMock('bar[baz]'));
$this->assertEquals(
array('foo[0]', 'foo[1]', 'bar[5]', 'bar[6]', 'bar[baz]'),
array_keys($registry->all())
);
}
public function testFormRegistrySetValues()
{
$registry = new FormFieldRegistry();
$registry->add($f2 = $this->getFormFieldMock('foo[2]'));
$registry->add($f3 = $this->getFormFieldMock('foo[3]'));
$registry->add($fbb = $this->getFormFieldMock('foo[bar][baz]'));
$f2
->expects($this->exactly(2))
->method('setValue')
->with(2)
;
$f3
->expects($this->exactly(2))
->method('setValue')
->with(3)
;
$fbb
->expects($this->exactly(2))
->method('setValue')
->with('fbb')
;
$registry->set('foo[2]', 2);
$registry->set('foo[3]', 3);
$registry->set('foo[bar][baz]', 'fbb');
$registry->set('foo', array(
2 => 2,
3 => 3,
'bar' => array(
'baz' => 'fbb'
)
));
}
protected function getFormFieldMock($name, $value = null)
{
$field = $this
->getMockBuilder('Symfony\\Component\\DomCrawler\\Field\\FormField')
->setMethods(array('getName', 'getValue', 'setValue', 'initialize'))
->disableOriginalConstructor()
->getMock()
;
$field
->expects($this->any())
->method('getName')
->will($this->returnValue($name))
;
$field
->expects($this->any())
->method('getValue')
->will($this->returnValue($value))
;
return $field;
}
protected function createForm($form, $method = null, $currentUri = null)
{
$dom = new \DOMDocument();
$dom->loadHTML(''.$form.'');
$nodes = $dom->getElementsByTagName('input');
$xPath = new \DOMXPath($dom);
$nodes = $xPath->query('//input | //button');
if (null === $currentUri) {
$currentUri = 'http://example.com/';
}
return new Form($nodes->item($nodes->length - 1), $currentUri, $method);
}
protected function createTestHtml5Form()
{
$dom = new \DOMDocument();
$dom->loadHTML('
Hello form
');
return $dom;
}
}
PK 3])q0l l - Symfony/Component/DomCrawler/phpunit.xml.distnu [
./Tests/././Resources./Tests./vendor
PK ]݂ ) Symfony/Component/DomCrawler/CHANGELOG.mdnu [ CHANGELOG
=========
2.4.0
-----
* `Crawler::addXmlContent()` removes the default document namespace again if it's an only namespace.
* added support for automatic discovery and explicit registration of document
namespaces for `Crawler::filterXPath()` and `Crawler::filter()`
* improved content type guessing in `Crawler::addContent()`
* [BC BREAK] `Crawler::addXmlContent()` no longer removes the default document
namespace
2.3.0
-----
* added Crawler::html()
* [BC BREAK] Crawler::each() and Crawler::reduce() now return Crawler instances instead of DomElement instances
* added schema relative URL support to links
* added support for HTML5 'form' attribute
2.2.0
-----
* added a way to set raw path to the file in FileFormField - necessary for
simulating HTTP requests
2.1.0
-----
* added support for the HTTP PATCH method
* refactored the Form class internals to support multi-dimensional fields
(the public API is backward compatible)
* added a way to get parsing errors for Crawler::addHtmlContent() and
Crawler::addXmlContent() via libxml functions
* added support for submitting a form without a submit button
PK ]E) ) $ Symfony/Component/DomCrawler/LICENSEnu [ Copyright (c) 2004-2014 Fabien Potencier
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
PK ]!j j * Symfony/Component/DomCrawler/composer.jsonnu [ {
"name": "symfony/dom-crawler",
"type": "library",
"description": "Symfony DomCrawler Component",
"keywords": [],
"homepage": "http://symfony.com",
"license": "MIT",
"authors": [
{
"name": "Fabien Potencier",
"email": "fabien@symfony.com"
},
{
"name": "Symfony Community",
"homepage": "http://symfony.com/contributors"
}
],
"require": {
"php": ">=5.3.3"
},
"require-dev": {
"symfony/css-selector": "~2.0"
},
"suggest": {
"symfony/css-selector": ""
},
"autoload": {
"psr-0": { "Symfony\\Component\\DomCrawler\\": "" }
},
"target-dir": "Symfony/Component/DomCrawler",
"minimum-stability": "dev",
"extra": {
"branch-alias": {
"dev-master": "2.4-dev"
}
}
}
PK ];|\e e &