/vendor/symfony/dom-crawler/Crawler.php |
@@ -0,0 +1,1209 @@ |
<?php |
|
/* |
* This file is part of the Symfony package. |
* |
* (c) Fabien Potencier <fabien@symfony.com> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Symfony\Component\DomCrawler; |
|
use Symfony\Component\CssSelector\CssSelectorConverter; |
|
/** |
* Crawler eases navigation of a list of \DOMNode objects. |
* |
* @author Fabien Potencier <fabien@symfony.com> |
*/ |
class Crawler extends \SplObjectStorage |
{ |
/** |
* @var string The current URI |
*/ |
protected $uri; |
|
/** |
* @var string The default namespace prefix to be used with XPath and CSS expressions |
*/ |
private $defaultNamespacePrefix = 'default'; |
|
/** |
* @var array A map of manually registered namespaces |
*/ |
private $namespaces = array(); |
|
/** |
* @var string The base href value |
*/ |
private $baseHref; |
|
/** |
* @var \DOMDocument|null |
*/ |
private $document; |
|
/** |
* Whether the Crawler contains HTML or XML content (used when converting CSS to XPath). |
* |
* @var bool |
*/ |
private $isHtml = true; |
|
/** |
* Constructor. |
* |
* @param mixed $node A Node to use as the base for the crawling |
* @param string $currentUri The current URI |
* @param string $baseHref The base href value |
*/ |
public function __construct($node = null, $currentUri = null, $baseHref = null) |
{ |
$this->uri = $currentUri; |
$this->baseHref = $baseHref ?: $currentUri; |
|
$this->add($node); |
} |
|
/** |
* Removes all the nodes. |
*/ |
public function clear() |
{ |
parent::removeAll($this); |
$this->document = null; |
} |
|
/** |
* Adds a node to the current list of nodes. |
* |
* This method uses the appropriate specialized add*() method based |
* on the type of the argument. |
* |
* @param \DOMNodeList|\DOMNode|array|string|null $node A node |
* |
* @throws \InvalidArgumentException When node is not the expected type. |
*/ |
public function add($node) |
{ |
if ($node instanceof \DOMNodeList) { |
$this->addNodeList($node); |
} elseif ($node instanceof \DOMNode) { |
$this->addNode($node); |
} elseif (is_array($node)) { |
$this->addNodes($node); |
} elseif (is_string($node)) { |
$this->addContent($node); |
} elseif (null !== $node) { |
throw new \InvalidArgumentException(sprintf('Expecting a DOMNodeList or DOMNode instance, an array, a string, or null, but got "%s".', is_object($node) ? get_class($node) : gettype($node))); |
} |
} |
|
/** |
* Adds HTML/XML content. |
* |
* If the charset is not set via the content type, it is assumed |
* to be ISO-8859-1, which is the default charset defined by the |
* HTTP 1.1 specification. |
* |
* @param string $content A string to parse as HTML/XML |
* @param null|string $type The content type of the string |
*/ |
public function addContent($content, $type = null) |
{ |
if (empty($type)) { |
$type = 0 === strpos($content, '<?xml') ? 'application/xml' : 'text/html'; |
} |
|
// DOM only for HTML/XML content |
if (!preg_match('/(x|ht)ml/i', $type, $xmlMatches)) { |
return; |
} |
|
$charset = null; |
if (false !== $pos = stripos($type, 'charset=')) { |
$charset = substr($type, $pos + 8); |
if (false !== $pos = strpos($charset, ';')) { |
$charset = substr($charset, 0, $pos); |
} |
} |
|
// http://www.w3.org/TR/encoding/#encodings |
// http://www.w3.org/TR/REC-xml/#NT-EncName |
if (null === $charset && |
preg_match('/\<meta[^\>]+charset *= *["\']?([a-zA-Z\-0-9_:.]+)/i', $content, $matches)) { |
$charset = $matches[1]; |
} |
|
if (null === $charset) { |
$charset = 'ISO-8859-1'; |
} |
|
if ('x' === $xmlMatches[1]) { |
$this->addXmlContent($content, $charset); |
} else { |
$this->addHtmlContent($content, $charset); |
} |
} |
|
/** |
* Adds an HTML content to the list of nodes. |
* |
* The libxml errors are disabled when the content is parsed. |
* |
* If you want to get parsing errors, be sure to enable |
* internal errors via libxml_use_internal_errors(true) |
* and then, get the errors via libxml_get_errors(). Be |
* sure to clear errors with libxml_clear_errors() afterward. |
* |
* @param string $content The HTML content |
* @param string $charset The charset |
*/ |
public function addHtmlContent($content, $charset = 'UTF-8') |
{ |
$internalErrors = libxml_use_internal_errors(true); |
$disableEntities = libxml_disable_entity_loader(true); |
|
$dom = new \DOMDocument('1.0', $charset); |
$dom->validateOnParse = true; |
|
set_error_handler(function () { throw new \Exception(); }); |
|
try { |
// Convert charset to HTML-entities to work around bugs in DOMDocument::loadHTML() |
$content = mb_convert_encoding($content, 'HTML-ENTITIES', $charset); |
} catch (\Exception $e) { |
} |
|
restore_error_handler(); |
|
if ('' !== trim($content)) { |
@$dom->loadHTML($content); |
} |
|
libxml_use_internal_errors($internalErrors); |
libxml_disable_entity_loader($disableEntities); |
|
$this->addDocument($dom); |
|
$base = $this->filterRelativeXPath('descendant-or-self::base')->extract(array('href')); |
|
$baseHref = current($base); |
if (count($base) && !empty($baseHref)) { |
if ($this->baseHref) { |
$linkNode = $dom->createElement('a'); |
$linkNode->setAttribute('href', $baseHref); |
$link = new Link($linkNode, $this->baseHref); |
$this->baseHref = $link->getUri(); |
} else { |
$this->baseHref = $baseHref; |
} |
} |
} |
|
/** |
* Adds an XML content to the list of nodes. |
* |
* The libxml errors are disabled when the content is parsed. |
* |
* If you want to get parsing errors, be sure to enable |
* internal errors via libxml_use_internal_errors(true) |
* and then, get the errors via libxml_get_errors(). Be |
* sure to clear errors with libxml_clear_errors() afterward. |
* |
* @param string $content The XML content |
* @param string $charset The charset |
* @param int $options Bitwise OR of the libxml option constants |
* LIBXML_PARSEHUGE is dangerous, see |
* http://symfony.com/blog/security-release-symfony-2-0-17-released |
*/ |
public function addXmlContent($content, $charset = 'UTF-8', $options = LIBXML_NONET) |
{ |
// remove the default namespace if it's the only namespace to make XPath expressions simpler |
if (!preg_match('/xmlns:/', $content)) { |
$content = str_replace('xmlns', 'ns', $content); |
} |
|
$internalErrors = libxml_use_internal_errors(true); |
$disableEntities = libxml_disable_entity_loader(true); |
|
$dom = new \DOMDocument('1.0', $charset); |
$dom->validateOnParse = true; |
|
if ('' !== trim($content)) { |
@$dom->loadXML($content, $options); |
} |
|
libxml_use_internal_errors($internalErrors); |
libxml_disable_entity_loader($disableEntities); |
|
$this->addDocument($dom); |
|
$this->isHtml = false; |
} |
|
/** |
* Adds a \DOMDocument to the list of nodes. |
* |
* @param \DOMDocument $dom A \DOMDocument instance |
*/ |
public function addDocument(\DOMDocument $dom) |
{ |
if ($dom->documentElement) { |
$this->addNode($dom->documentElement); |
} |
} |
|
/** |
* Adds a \DOMNodeList to the list of nodes. |
* |
* @param \DOMNodeList $nodes A \DOMNodeList instance |
*/ |
public function addNodeList(\DOMNodeList $nodes) |
{ |
foreach ($nodes as $node) { |
if ($node instanceof \DOMNode) { |
$this->addNode($node); |
} |
} |
} |
|
/** |
* Adds an array of \DOMNode instances to the list of nodes. |
* |
* @param \DOMNode[] $nodes An array of \DOMNode instances |
*/ |
public function addNodes(array $nodes) |
{ |
foreach ($nodes as $node) { |
$this->add($node); |
} |
} |
|
/** |
* Adds a \DOMNode instance to the list of nodes. |
* |
* @param \DOMNode $node A \DOMNode instance |
*/ |
public function addNode(\DOMNode $node) |
{ |
if ($node instanceof \DOMDocument) { |
$node = $node->documentElement; |
} |
|
if (null !== $this->document && $this->document !== $node->ownerDocument) { |
@trigger_error('Attaching DOM nodes from multiple documents in a Crawler is deprecated as of 2.8 and will be forbidden in 3.0.', E_USER_DEPRECATED); |
} |
|
if (null === $this->document) { |
$this->document = $node->ownerDocument; |
} |
|
parent::attach($node); |
} |
|
// Serializing and unserializing a crawler creates DOM objects in a corrupted state. DOM elements are not properly serializable. |
public function unserialize($serialized) |
{ |
throw new \BadMethodCallException('A Crawler cannot be serialized.'); |
} |
|
public function serialize() |
{ |
throw new \BadMethodCallException('A Crawler cannot be serialized.'); |
} |
|
/** |
* Returns a node given its position in the node list. |
* |
* @param int $position The position |
* |
* @return self |
*/ |
public function eq($position) |
{ |
foreach ($this as $i => $node) { |
if ($i == $position) { |
return $this->createSubCrawler($node); |
} |
} |
|
return $this->createSubCrawler(null); |
} |
|
/** |
* Calls an anonymous function on each node of the list. |
* |
* The anonymous function receives the position and the node wrapped |
* in a Crawler instance as arguments. |
* |
* Example: |
* |
* $crawler->filter('h1')->each(function ($node, $i) { |
* return $node->text(); |
* }); |
* |
* @param \Closure $closure An anonymous function |
* |
* @return array An array of values returned by the anonymous function |
*/ |
public function each(\Closure $closure) |
{ |
$data = array(); |
foreach ($this as $i => $node) { |
$data[] = $closure($this->createSubCrawler($node), $i); |
} |
|
return $data; |
} |
|
/** |
* Slices the list of nodes by $offset and $length. |
* |
* @param int $offset |
* @param int $length |
* |
* @return self |
*/ |
public function slice($offset = 0, $length = -1) |
{ |
return $this->createSubCrawler(iterator_to_array(new \LimitIterator($this, $offset, $length))); |
} |
|
/** |
* Reduces the list of nodes by calling an anonymous function. |
* |
* To remove a node from the list, the anonymous function must return false. |
* |
* @param \Closure $closure An anonymous function |
* |
* @return self |
*/ |
public function reduce(\Closure $closure) |
{ |
$nodes = array(); |
foreach ($this as $i => $node) { |
if (false !== $closure($this->createSubCrawler($node), $i)) { |
$nodes[] = $node; |
} |
} |
|
return $this->createSubCrawler($nodes); |
} |
|
/** |
* Returns the first node of the current selection. |
* |
* @return self |
*/ |
public function first() |
{ |
return $this->eq(0); |
} |
|
/** |
* Returns the last node of the current selection. |
* |
* @return self |
*/ |
public function last() |
{ |
return $this->eq(count($this) - 1); |
} |
|
/** |
* Returns the siblings nodes of the current selection. |
* |
* @return self |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function siblings() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
return $this->createSubCrawler($this->sibling($this->getNode(0)->parentNode->firstChild)); |
} |
|
/** |
* Returns the next siblings nodes of the current selection. |
* |
* @return self |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function nextAll() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
return $this->createSubCrawler($this->sibling($this->getNode(0))); |
} |
|
/** |
* Returns the previous sibling nodes of the current selection. |
* |
* @return self |
* |
* @throws \InvalidArgumentException |
*/ |
public function previousAll() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
return $this->createSubCrawler($this->sibling($this->getNode(0), 'previousSibling')); |
} |
|
/** |
* Returns the parents nodes of the current selection. |
* |
* @return self |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function parents() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$node = $this->getNode(0); |
$nodes = array(); |
|
while ($node = $node->parentNode) { |
if (XML_ELEMENT_NODE === $node->nodeType) { |
$nodes[] = $node; |
} |
} |
|
return $this->createSubCrawler($nodes); |
} |
|
/** |
* Returns the children nodes of the current selection. |
* |
* @return self |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function children() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$node = $this->getNode(0)->firstChild; |
|
return $this->createSubCrawler($node ? $this->sibling($node) : array()); |
} |
|
/** |
* Returns the attribute value of the first node of the list. |
* |
* @param string $attribute The attribute name |
* |
* @return string|null The attribute value or null if the attribute does not exist |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function attr($attribute) |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$node = $this->getNode(0); |
|
return $node->hasAttribute($attribute) ? $node->getAttribute($attribute) : null; |
} |
|
/** |
* Returns the node name of the first node of the list. |
* |
* @return string The node name |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function nodeName() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
return $this->getNode(0)->nodeName; |
} |
|
/** |
* Returns the node value of the first node of the list. |
* |
* @return string The node value |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function text() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
return $this->getNode(0)->nodeValue; |
} |
|
/** |
* Returns the first node of the list as HTML. |
* |
* @return string The node html |
* |
* @throws \InvalidArgumentException When current node is empty |
*/ |
public function html() |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$html = ''; |
foreach ($this->getNode(0)->childNodes as $child) { |
$html .= $child->ownerDocument->saveHTML($child); |
} |
|
return $html; |
} |
|
/** |
* Extracts information from the list of nodes. |
* |
* You can extract attributes or/and the node value (_text). |
* |
* Example: |
* |
* $crawler->filter('h1 a')->extract(array('_text', 'href')); |
* |
* @param array $attributes An array of attributes |
* |
* @return array An array of extracted values |
*/ |
public function extract($attributes) |
{ |
$attributes = (array) $attributes; |
$count = count($attributes); |
|
$data = array(); |
foreach ($this as $node) { |
$elements = array(); |
foreach ($attributes as $attribute) { |
if ('_text' === $attribute) { |
$elements[] = $node->nodeValue; |
} else { |
$elements[] = $node->getAttribute($attribute); |
} |
} |
|
$data[] = $count > 1 ? $elements : $elements[0]; |
} |
|
return $data; |
} |
|
/** |
* Filters the list of nodes with an XPath expression. |
* |
* The XPath expression is evaluated in the context of the crawler, which |
* is considered as a fake parent of the elements inside it. |
* This means that a child selector "div" or "./div" will match only |
* the div elements of the current crawler, not their children. |
* |
* @param string $xpath An XPath expression |
* |
* @return self |
*/ |
public function filterXPath($xpath) |
{ |
$xpath = $this->relativize($xpath); |
|
// If we dropped all expressions in the XPath while preparing it, there would be no match |
if ('' === $xpath) { |
return $this->createSubCrawler(null); |
} |
|
return $this->filterRelativeXPath($xpath); |
} |
|
/** |
* Filters the list of nodes with a CSS selector. |
* |
* This method only works if you have installed the CssSelector Symfony Component. |
* |
* @param string $selector A CSS selector |
* |
* @return self |
* |
* @throws \RuntimeException if the CssSelector Component is not available |
*/ |
public function filter($selector) |
{ |
if (!class_exists('Symfony\\Component\\CssSelector\\CssSelectorConverter')) { |
throw new \RuntimeException('Unable to filter with a CSS selector as the Symfony CssSelector 2.8+ is not installed (you can use filterXPath instead).'); |
} |
|
$converter = new CssSelectorConverter($this->isHtml); |
|
// The CssSelector already prefixes the selector with descendant-or-self:: |
return $this->filterRelativeXPath($converter->toXPath($selector)); |
} |
|
/** |
* Selects links by name or alt value for clickable images. |
* |
* @param string $value The link text |
* |
* @return self |
*/ |
public function selectLink($value) |
{ |
$xpath = sprintf('descendant-or-self::a[contains(concat(\' \', normalize-space(string(.)), \' \'), %s) ', static::xpathLiteral(' '.$value.' ')). |
sprintf('or ./img[contains(concat(\' \', normalize-space(string(@alt)), \' \'), %s)]]', static::xpathLiteral(' '.$value.' ')); |
|
return $this->filterRelativeXPath($xpath); |
} |
|
/** |
* Selects a button by name or alt value for images. |
* |
* @param string $value The button text |
* |
* @return self |
*/ |
public function selectButton($value) |
{ |
$translate = 'translate(@type, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz")'; |
$xpath = sprintf('descendant-or-self::input[((contains(%s, "submit") or contains(%s, "button")) and contains(concat(\' \', normalize-space(string(@value)), \' \'), %s)) ', $translate, $translate, static::xpathLiteral(' '.$value.' ')). |
sprintf('or (contains(%s, "image") and contains(concat(\' \', normalize-space(string(@alt)), \' \'), %s)) or @id=%s or @name=%s] ', $translate, static::xpathLiteral(' '.$value.' '), static::xpathLiteral($value), static::xpathLiteral($value)). |
sprintf('| descendant-or-self::button[contains(concat(\' \', normalize-space(string(.)), \' \'), %s) or @id=%s or @name=%s]', static::xpathLiteral(' '.$value.' '), static::xpathLiteral($value), static::xpathLiteral($value)); |
|
return $this->filterRelativeXPath($xpath); |
} |
|
/** |
* Returns a Link object for the first node in the list. |
* |
* @param string $method The method for the link (get by default) |
* |
* @return Link A Link instance |
* |
* @throws \InvalidArgumentException If the current node list is empty or the selected node is not instance of DOMElement |
*/ |
public function link($method = 'get') |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$node = $this->getNode(0); |
|
if (!$node instanceof \DOMElement) { |
throw new \InvalidArgumentException(sprintf('The selected node should be instance of DOMElement, got "%s".', get_class($node))); |
} |
|
return new Link($node, $this->baseHref, $method); |
} |
|
/** |
* Returns an array of Link objects for the nodes in the list. |
* |
* @return Link[] An array of Link instances |
* |
* @throws \InvalidArgumentException If the current node list contains non-DOMElement instances |
*/ |
public function links() |
{ |
$links = array(); |
foreach ($this as $node) { |
if (!$node instanceof \DOMElement) { |
throw new \InvalidArgumentException(sprintf('The current node list should contain only DOMElement instances, "%s" found.', get_class($node))); |
} |
|
$links[] = new Link($node, $this->baseHref, 'get'); |
} |
|
return $links; |
} |
|
/** |
* Returns a Form object for the first node in the list. |
* |
* @param array $values An array of values for the form fields |
* @param string $method The method for the form |
* |
* @return Form A Form instance |
* |
* @throws \InvalidArgumentException If the current node list is empty or the selected node is not instance of DOMElement |
*/ |
public function form(array $values = null, $method = null) |
{ |
if (!count($this)) { |
throw new \InvalidArgumentException('The current node list is empty.'); |
} |
|
$node = $this->getNode(0); |
|
if (!$node instanceof \DOMElement) { |
throw new \InvalidArgumentException(sprintf('The selected node should be instance of DOMElement, got "%s".', get_class($node))); |
} |
|
$form = new Form($node, $this->uri, $method, $this->baseHref); |
|
if (null !== $values) { |
$form->setValues($values); |
} |
|
return $form; |
} |
|
/** |
* Overloads a default namespace prefix to be used with XPath and CSS expressions. |
* |
* @param string $prefix |
*/ |
public function setDefaultNamespacePrefix($prefix) |
{ |
$this->defaultNamespacePrefix = $prefix; |
} |
|
/** |
* @param string $prefix |
* @param string $namespace |
*/ |
public function registerNamespace($prefix, $namespace) |
{ |
$this->namespaces[$prefix] = $namespace; |
} |
|
/** |
* Converts string for XPath expressions. |
* |
* Escaped characters are: quotes (") and apostrophe ('). |
* |
* Examples: |
* <code> |
* echo Crawler::xpathLiteral('foo " bar'); |
* //prints 'foo " bar' |
* |
* echo Crawler::xpathLiteral("foo ' bar"); |
* //prints "foo ' bar" |
* |
* echo Crawler::xpathLiteral('a\'b"c'); |
* //prints concat('a', "'", 'b"c') |
* </code> |
* |
* @param string $s String to be escaped |
* |
* @return string Converted string |
*/ |
public static function xpathLiteral($s) |
{ |
if (false === strpos($s, "'")) { |
return sprintf("'%s'", $s); |
} |
|
if (false === strpos($s, '"')) { |
return sprintf('"%s"', $s); |
} |
|
$string = $s; |
$parts = array(); |
while (true) { |
if (false !== $pos = strpos($string, "'")) { |
$parts[] = sprintf("'%s'", substr($string, 0, $pos)); |
$parts[] = "\"'\""; |
$string = substr($string, $pos + 1); |
} else { |
$parts[] = "'$string'"; |
break; |
} |
} |
|
return sprintf('concat(%s)', implode(', ', $parts)); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function attach($object, $data = null) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::attach($object, $data); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function detach($object) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::detach($object); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function contains($object) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
return parent::contains($object); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function addAll($storage) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::addAll($storage); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function removeAll($storage) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::removeAll($storage); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function removeAllExcept($storage) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::removeAllExcept($storage); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function getInfo() |
{ |
$this->triggerDeprecation(__METHOD__); |
|
return parent::getInfo(); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function setInfo($data) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::setInfo($data); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function offsetExists($object) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
return parent::offsetExists($object); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function offsetSet($object, $data = null) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::offsetSet($object, $data); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function offsetUnset($object) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
parent::offsetUnset($object); |
} |
|
/** |
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0. |
*/ |
public function offsetGet($object) |
{ |
$this->triggerDeprecation(__METHOD__); |
|
return parent::offsetGet($object); |
} |
|
/** |
* Filters the list of nodes with an XPath expression. |
* |
* The XPath expression should already be processed to apply it in the context of each node. |
* |
* @param string $xpath |
* |
* @return self |
*/ |
private function filterRelativeXPath($xpath) |
{ |
$prefixes = $this->findNamespacePrefixes($xpath); |
|
$crawler = $this->createSubCrawler(null); |
|
foreach ($this as $node) { |
$domxpath = $this->createDOMXPath($node->ownerDocument, $prefixes); |
$crawler->add($domxpath->query($xpath, $node)); |
} |
|
return $crawler; |
} |
|
/** |
* Make the XPath relative to the current context. |
* |
* The returned XPath will match elements matching the XPath inside the current crawler |
* when running in the context of a node of the crawler. |
* |
* @param string $xpath |
* |
* @return string |
*/ |
private function relativize($xpath) |
{ |
$expressions = array(); |
|
// An expression which will never match to replace expressions which cannot match in the crawler |
// We cannot simply drop |
$nonMatchingExpression = 'a[name() = "b"]'; |
|
$xpathLen = strlen($xpath); |
$openedBrackets = 0; |
$startPosition = strspn($xpath, " \t\n\r\0\x0B"); |
|
for ($i = $startPosition; $i <= $xpathLen; ++$i) { |
$i += strcspn($xpath, '"\'[]|', $i); |
|
if ($i < $xpathLen) { |
switch ($xpath[$i]) { |
case '"': |
case "'": |
if (false === $i = strpos($xpath, $xpath[$i], $i + 1)) { |
return $xpath; // The XPath expression is invalid |
} |
continue 2; |
case '[': |
++$openedBrackets; |
continue 2; |
case ']': |
--$openedBrackets; |
continue 2; |
} |
} |
if ($openedBrackets) { |
continue; |
} |
|
if ($startPosition < $xpathLen && '(' === $xpath[$startPosition]) { |
// If the union is inside some braces, we need to preserve the opening braces and apply |
// the change only inside it. |
$j = 1 + strspn($xpath, "( \t\n\r\0\x0B", $startPosition + 1); |
$parenthesis = substr($xpath, $startPosition, $j); |
$startPosition += $j; |
} else { |
$parenthesis = ''; |
} |
$expression = rtrim(substr($xpath, $startPosition, $i - $startPosition)); |
|
// BC for Symfony 2.4 and lower were elements were adding in a fake _root parent |
if (0 === strpos($expression, '/_root/')) { |
@trigger_error('XPath expressions referencing the fake root node are deprecated since version 2.8 and will be unsupported in 3.0. Please use "./" instead of "/_root/".', E_USER_DEPRECATED); |
|
$expression = './'.substr($expression, 7); |
} elseif (0 === strpos($expression, 'self::*/')) { |
$expression = './'.substr($expression, 8); |
} |
|
// add prefix before absolute element selector |
if ('' === $expression) { |
$expression = $nonMatchingExpression; |
} elseif (0 === strpos($expression, '//')) { |
$expression = 'descendant-or-self::'.substr($expression, 2); |
} elseif (0 === strpos($expression, './/')) { |
$expression = 'descendant-or-self::'.substr($expression, 3); |
} elseif (0 === strpos($expression, './')) { |
$expression = 'self::'.substr($expression, 2); |
} elseif (0 === strpos($expression, 'child::')) { |
$expression = 'self::'.substr($expression, 7); |
} elseif ('/' === $expression[0] || 0 === strpos($expression, 'self::')) { |
// the only direct child in Symfony 2.4 and lower is _root, which is already handled previously |
// so let's drop the expression entirely |
$expression = $nonMatchingExpression; |
} elseif ('.' === $expression[0]) { |
// '.' is the fake root element in Symfony 2.4 and lower, which is excluded from results |
$expression = $nonMatchingExpression; |
} elseif (0 === strpos($expression, 'descendant::')) { |
$expression = 'descendant-or-self::'.substr($expression, 12); |
} elseif (preg_match('/^(ancestor|ancestor-or-self|attribute|following|following-sibling|namespace|parent|preceding|preceding-sibling)::/', $expression)) { |
// the fake root has no parent, preceding or following nodes and also no attributes (even no namespace attributes) |
$expression = $nonMatchingExpression; |
} elseif (0 !== strpos($expression, 'descendant-or-self::')) { |
$expression = 'self::'.$expression; |
} |
$expressions[] = $parenthesis.$expression; |
|
if ($i === $xpathLen) { |
return implode(' | ', $expressions); |
} |
|
$i += strspn($xpath, " \t\n\r\0\x0B", $i + 1); |
$startPosition = $i + 1; |
} |
|
return $xpath; // The XPath expression is invalid |
} |
|
/** |
* @param int $position |
* |
* @return \DOMElement|null |
*/ |
public function getNode($position) |
{ |
foreach ($this as $i => $node) { |
if ($i == $position) { |
return $node; |
} |
} |
} |
|
/** |
* @param \DOMElement $node |
* @param string $siblingDir |
* |
* @return array |
*/ |
protected function sibling($node, $siblingDir = 'nextSibling') |
{ |
$nodes = array(); |
|
do { |
if ($node !== $this->getNode(0) && $node->nodeType === 1) { |
$nodes[] = $node; |
} |
} while ($node = $node->$siblingDir); |
|
return $nodes; |
} |
|
/** |
* @param \DOMDocument $document |
* @param array $prefixes |
* |
* @return \DOMXPath |
* |
* @throws \InvalidArgumentException |
*/ |
private function createDOMXPath(\DOMDocument $document, array $prefixes = array()) |
{ |
$domxpath = new \DOMXPath($document); |
|
foreach ($prefixes as $prefix) { |
$namespace = $this->discoverNamespace($domxpath, $prefix); |
if (null !== $namespace) { |
$domxpath->registerNamespace($prefix, $namespace); |
} |
} |
|
return $domxpath; |
} |
|
/** |
* @param \DOMXPath $domxpath |
* @param string $prefix |
* |
* @return string |
* |
* @throws \InvalidArgumentException |
*/ |
private function discoverNamespace(\DOMXPath $domxpath, $prefix) |
{ |
if (isset($this->namespaces[$prefix])) { |
return $this->namespaces[$prefix]; |
} |
|
// ask for one namespace, otherwise we'd get a collection with an item for each node |
$namespaces = $domxpath->query(sprintf('(//namespace::*[name()="%s"])[last()]', $this->defaultNamespacePrefix === $prefix ? '' : $prefix)); |
|
if ($node = $namespaces->item(0)) { |
return $node->nodeValue; |
} |
} |
|
/** |
* @param string $xpath |
* |
* @return array |
*/ |
private function findNamespacePrefixes($xpath) |
{ |
if (preg_match_all('/(?P<prefix>[a-z_][a-z_0-9\-\.]*+):[^"\/:]/i', $xpath, $matches)) { |
return array_unique($matches['prefix']); |
} |
|
return array(); |
} |
|
/** |
* Creates a crawler for some subnodes. |
* |
* @param \DOMElement|\DOMElement[]|\DOMNodeList|null $nodes |
* |
* @return static |
*/ |
private function createSubCrawler($nodes) |
{ |
$crawler = new static($nodes, $this->uri, $this->baseHref); |
$crawler->isHtml = $this->isHtml; |
$crawler->document = $this->document; |
$crawler->namespaces = $this->namespaces; |
|
return $crawler; |
} |
|
private function triggerDeprecation($methodName, $useTrace = false) |
{ |
if ($useTrace || defined('HHVM_VERSION')) { |
if (PHP_VERSION_ID >= 50400) { |
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3); |
} else { |
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); |
} |
|
// The SplObjectStorage class performs calls to its own methods. These |
// method calls must not lead to triggered deprecation notices. |
if (isset($trace[2]['class']) && 'SplObjectStorage' === $trace[2]['class']) { |
return; |
} |
} |
|
@trigger_error('The '.$methodName.' method is deprecated since version 2.8 and will be removed in 3.0.', E_USER_DEPRECATED); |
} |
} |
/vendor/symfony/dom-crawler/Form.php |
@@ -0,0 +1,473 @@ |
<?php |
|
/* |
* This file is part of the Symfony package. |
* |
* (c) Fabien Potencier <fabien@symfony.com> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Symfony\Component\DomCrawler; |
|
use Symfony\Component\DomCrawler\Field\ChoiceFormField; |
use Symfony\Component\DomCrawler\Field\FormField; |
|
/** |
* Form represents an HTML form. |
* |
* @author Fabien Potencier <fabien@symfony.com> |
*/ |
class Form extends Link implements \ArrayAccess |
{ |
/** |
* @var \DOMElement |
*/ |
private $button; |
|
/** |
* @var FormFieldRegistry |
*/ |
private $fields; |
|
/** |
* @var string |
*/ |
private $baseHref; |
|
/** |
* Constructor. |
* |
* @param \DOMElement $node A \DOMElement instance |
* @param string $currentUri The URI of the page where the form is embedded |
* @param string $method The method to use for the link (if null, it defaults to the method defined by the form) |
* @param string $baseHref The URI of the <base> used for relative links, but not for empty action |
* |
* @throws \LogicException if the node is not a button inside a form tag |
*/ |
public function __construct(\DOMElement $node, $currentUri, $method = null, $baseHref = null) |
{ |
parent::__construct($node, $currentUri, $method); |
$this->baseHref = $baseHref; |
|
$this->initialize(); |
} |
|
/** |
* Gets the form node associated with this form. |
* |
* @return \DOMElement A \DOMElement instance |
*/ |
public function getFormNode() |
{ |
return $this->node; |
} |
|
/** |
* Sets the value of the fields. |
* |
* @param array $values An array of field values |
* |
* @return $this |
*/ |
public function setValues(array $values) |
{ |
foreach ($values as $name => $value) { |
$this->fields->set($name, $value); |
} |
|
return $this; |
} |
|
/** |
* Gets the field values. |
* |
* The returned array does not include file fields (@see getFiles). |
* |
* @return array An array of field values |
*/ |
public function getValues() |
{ |
$values = array(); |
foreach ($this->fields->all() as $name => $field) { |
if ($field->isDisabled()) { |
continue; |
} |
|
if (!$field instanceof Field\FileFormField && $field->hasValue()) { |
$values[$name] = $field->getValue(); |
} |
} |
|
return $values; |
} |
|
/** |
* Gets the file field values. |
* |
* @return array An array of file field values |
*/ |
public function getFiles() |
{ |
if (!in_array($this->getMethod(), array('POST', 'PUT', 'DELETE', 'PATCH'))) { |
return array(); |
} |
|
$files = array(); |
|
foreach ($this->fields->all() as $name => $field) { |
if ($field->isDisabled()) { |
continue; |
} |
|
if ($field instanceof Field\FileFormField) { |
$files[$name] = $field->getValue(); |
} |
} |
|
return $files; |
} |
|
/** |
* Gets the field values as PHP. |
* |
* This method converts fields with the array notation |
* (like foo[bar] to arrays) like PHP does. |
* |
* @return array An array of field values |
*/ |
public function getPhpValues() |
{ |
$values = array(); |
foreach ($this->getValues() as $name => $value) { |
$qs = http_build_query(array($name => $value), '', '&'); |
if (!empty($qs)) { |
parse_str($qs, $expandedValue); |
$varName = substr($name, 0, strlen(key($expandedValue))); |
$values = array_replace_recursive($values, array($varName => current($expandedValue))); |
} |
} |
|
return $values; |
} |
|
/** |
* Gets the file field values as PHP. |
* |
* This method converts fields with the array notation |
* (like foo[bar] to arrays) like PHP does. |
* The returned array is consistent with the array for field values |
* (@see getPhpValues), rather than uploaded files found in $_FILES. |
* For a compound file field foo[bar] it will create foo[bar][name], |
* instead of foo[name][bar] which would be found in $_FILES. |
* |
* @return array An array of file field values |
*/ |
public function getPhpFiles() |
{ |
$values = array(); |
foreach ($this->getFiles() as $name => $value) { |
$qs = http_build_query(array($name => $value), '', '&'); |
if (!empty($qs)) { |
parse_str($qs, $expandedValue); |
$varName = substr($name, 0, strlen(key($expandedValue))); |
$values = array_replace_recursive($values, array($varName => current($expandedValue))); |
} |
} |
|
return $values; |
} |
|
/** |
* Gets the URI of the form. |
* |
* The returned URI is not the same as the form "action" attribute. |
* This method merges the value if the method is GET to mimics |
* browser behavior. |
* |
* @return string The URI |
*/ |
public function getUri() |
{ |
$uri = parent::getUri(); |
|
if (!in_array($this->getMethod(), array('POST', 'PUT', 'DELETE', 'PATCH'))) { |
$query = parse_url($uri, PHP_URL_QUERY); |
$currentParameters = array(); |
if ($query) { |
parse_str($query, $currentParameters); |
} |
|
$queryString = http_build_query(array_merge($currentParameters, $this->getValues()), null, '&'); |
|
$pos = strpos($uri, '?'); |
$base = false === $pos ? $uri : substr($uri, 0, $pos); |
$uri = rtrim($base.'?'.$queryString, '?'); |
} |
|
return $uri; |
} |
|
protected function getRawUri() |
{ |
return $this->node->getAttribute('action'); |
} |
|
/** |
* Gets the form method. |
* |
* If no method is defined in the form, GET is returned. |
* |
* @return string The method |
*/ |
public function getMethod() |
{ |
if (null !== $this->method) { |
return $this->method; |
} |
|
return $this->node->getAttribute('method') ? strtoupper($this->node->getAttribute('method')) : 'GET'; |
} |
|
/** |
* Returns true if the named field exists. |
* |
* @param string $name The field name |
* |
* @return bool true if the field exists, false otherwise |
*/ |
public function has($name) |
{ |
return $this->fields->has($name); |
} |
|
/** |
* Removes a field from the form. |
* |
* @param string $name The field name |
*/ |
public function remove($name) |
{ |
$this->fields->remove($name); |
} |
|
/** |
* Gets a named field. |
* |
* @param string $name The field name |
* |
* @return FormField The field instance |
* |
* @throws \InvalidArgumentException When field is not present in this form |
*/ |
public function get($name) |
{ |
return $this->fields->get($name); |
} |
|
/** |
* Sets a named field. |
* |
* @param FormField $field The field |
*/ |
public function set(FormField $field) |
{ |
$this->fields->add($field); |
} |
|
/** |
* Gets all fields. |
* |
* @return FormField[] |
*/ |
public function all() |
{ |
return $this->fields->all(); |
} |
|
/** |
* Returns true if the named field exists. |
* |
* @param string $name The field name |
* |
* @return bool true if the field exists, false otherwise |
*/ |
public function offsetExists($name) |
{ |
return $this->has($name); |
} |
|
/** |
* Gets the value of a field. |
* |
* @param string $name The field name |
* |
* @return FormField The associated Field instance |
* |
* @throws \InvalidArgumentException if the field does not exist |
*/ |
public function offsetGet($name) |
{ |
return $this->fields->get($name); |
} |
|
/** |
* Sets the value of a field. |
* |
* @param string $name The field name |
* @param string|array $value The value of the field |
* |
* @throws \InvalidArgumentException if the field does not exist |
*/ |
public function offsetSet($name, $value) |
{ |
$this->fields->set($name, $value); |
} |
|
/** |
* Removes a field from the form. |
* |
* @param string $name The field name |
*/ |
public function offsetUnset($name) |
{ |
$this->fields->remove($name); |
} |
|
/** |
* Disables validation. |
* |
* @return self |
*/ |
public function disableValidation() |
{ |
foreach ($this->fields->all() as $field) { |
if ($field instanceof Field\ChoiceFormField) { |
$field->disableValidation(); |
} |
} |
|
return $this; |
} |
|
/** |
* Sets the node for the form. |
* |
* Expects a 'submit' button \DOMElement and finds the corresponding form element, or the form element itself. |
* |
* @param \DOMElement $node A \DOMElement instance |
* |
* @throws \LogicException If given node is not a button or input or does not have a form ancestor |
*/ |
protected function setNode(\DOMElement $node) |
{ |
$this->button = $node; |
if ('button' === $node->nodeName || ('input' === $node->nodeName && in_array(strtolower($node->getAttribute('type')), array('submit', 'button', 'image')))) { |
if ($node->hasAttribute('form')) { |
// if the node has the HTML5-compliant 'form' attribute, use it |
$formId = $node->getAttribute('form'); |
$form = $node->ownerDocument->getElementById($formId); |
if (null === $form) { |
throw new \LogicException(sprintf('The selected node has an invalid form attribute (%s).', $formId)); |
} |
$this->node = $form; |
|
return; |
} |
// we loop until we find a form ancestor |
do { |
if (null === $node = $node->parentNode) { |
throw new \LogicException('The selected node does not have a form ancestor.'); |
} |
} while ('form' !== $node->nodeName); |
} elseif ('form' !== $node->nodeName) { |
throw new \LogicException(sprintf('Unable to submit on a "%s" tag.', $node->nodeName)); |
} |
|
$this->node = $node; |
} |
|
/** |
* Adds form elements related to this form. |
* |
* Creates an internal copy of the submitted 'button' element and |
* the form node or the entire document depending on whether we need |
* to find non-descendant elements through HTML5 'form' attribute. |
*/ |
private function initialize() |
{ |
$this->fields = new FormFieldRegistry(); |
|
$xpath = new \DOMXPath($this->node->ownerDocument); |
|
// add submitted button if it has a valid name |
if ('form' !== $this->button->nodeName && $this->button->hasAttribute('name') && $this->button->getAttribute('name')) { |
if ('input' == $this->button->nodeName && 'image' == strtolower($this->button->getAttribute('type'))) { |
$name = $this->button->getAttribute('name'); |
$this->button->setAttribute('value', '0'); |
|
// temporarily change the name of the input node for the x coordinate |
$this->button->setAttribute('name', $name.'.x'); |
$this->set(new Field\InputFormField($this->button)); |
|
// temporarily change the name of the input node for the y coordinate |
$this->button->setAttribute('name', $name.'.y'); |
$this->set(new Field\InputFormField($this->button)); |
|
// restore the original name of the input node |
$this->button->setAttribute('name', $name); |
} else { |
$this->set(new Field\InputFormField($this->button)); |
} |
} |
|
// find form elements corresponding to the current form |
if ($this->node->hasAttribute('id')) { |
// corresponding elements are either descendants or have a matching HTML5 form attribute |
$formId = Crawler::xpathLiteral($this->node->getAttribute('id')); |
|
$fieldNodes = $xpath->query(sprintf('descendant::input[@form=%s] | descendant::button[@form=%s] | descendant::textarea[@form=%s] | descendant::select[@form=%s] | //form[@id=%s]//input[not(@form)] | //form[@id=%s]//button[not(@form)] | //form[@id=%s]//textarea[not(@form)] | //form[@id=%s]//select[not(@form)]', $formId, $formId, $formId, $formId, $formId, $formId, $formId, $formId)); |
foreach ($fieldNodes as $node) { |
$this->addField($node); |
} |
} else { |
// do the xpath query with $this->node as the context node, to only find descendant elements |
// however, descendant elements with form attribute are not part of this form |
$fieldNodes = $xpath->query('descendant::input[not(@form)] | descendant::button[not(@form)] | descendant::textarea[not(@form)] | descendant::select[not(@form)]', $this->node); |
foreach ($fieldNodes as $node) { |
$this->addField($node); |
} |
} |
|
if ($this->baseHref && '' !== $this->node->getAttribute('action')) { |
$this->currentUri = $this->baseHref; |
} |
} |
|
private function addField(\DOMElement $node) |
{ |
if (!$node->hasAttribute('name') || !$node->getAttribute('name')) { |
return; |
} |
|
$nodeName = $node->nodeName; |
if ('select' == $nodeName || 'input' == $nodeName && 'checkbox' == strtolower($node->getAttribute('type'))) { |
$this->set(new Field\ChoiceFormField($node)); |
} elseif ('input' == $nodeName && 'radio' == strtolower($node->getAttribute('type'))) { |
// there may be other fields with the same name that are no choice |
// fields already registered (see https://github.com/symfony/symfony/issues/11689) |
if ($this->has($node->getAttribute('name')) && $this->get($node->getAttribute('name')) instanceof ChoiceFormField) { |
$this->get($node->getAttribute('name'))->addChoice($node); |
} else { |
$this->set(new Field\ChoiceFormField($node)); |
} |
} elseif ('input' == $nodeName && 'file' == strtolower($node->getAttribute('type'))) { |
$this->set(new Field\FileFormField($node)); |
} elseif ('input' == $nodeName && !in_array(strtolower($node->getAttribute('type')), array('submit', 'button', 'image'))) { |
$this->set(new Field\InputFormField($node)); |
} elseif ('textarea' == $nodeName) { |
$this->set(new Field\TextareaFormField($node)); |
} |
} |
} |
/vendor/symfony/dom-crawler/Tests/CrawlerTest.php |
@@ -0,0 +1,1109 @@ |
<?php |
|
/* |
* This file is part of the Symfony package. |
* |
* (c) Fabien Potencier <fabien@symfony.com> |
* |
* 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 PHPUnit\Framework\TestCase; |
use Symfony\Component\DomCrawler\Crawler; |
|
class CrawlerTest extends TestCase |
{ |
public function testConstructor() |
{ |
$crawler = new Crawler(); |
$this->assertCount(0, $crawler, '__construct() returns an empty crawler'); |
|
$doc = new \DOMDocument(); |
$node = $doc->createElement('test'); |
|
$crawler = new Crawler($node); |
$this->assertCount(1, $crawler, '__construct() takes a node as a first argument'); |
} |
|
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'); |
|
$list = array(); |
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 a \DOMNode'); |
|
$crawler = new Crawler(); |
$crawler->add('<html><body>Foo</body></html>'); |
$this->assertEquals('Foo', $crawler->filterXPath('//body')->text(), '->add() adds nodes from a string'); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testAddInvalidType() |
{ |
$crawler = new Crawler(); |
$crawler->add(1); |
} |
|
public function testAddHtmlContent() |
{ |
$crawler = new Crawler(); |
$crawler->addHtmlContent('<html><div class="foo"></html>', 'UTF-8'); |
|
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addHtmlContent() adds nodes from an HTML string'); |
} |
|
public function testAddHtmlContentWithBaseTag() |
{ |
$crawler = new Crawler(); |
|
$crawler->addHtmlContent('<html><head><base href="http://symfony.com"></head><a href="/contact"></a></html>', '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'); |
} |
|
/** |
* @requires extension mbstring |
*/ |
public function testAddHtmlContentCharset() |
{ |
$crawler = new Crawler(); |
$crawler->addHtmlContent('<html><div class="foo">Tiếng Việt</html>', 'UTF-8'); |
|
$this->assertEquals('Tiếng Việt', $crawler->filterXPath('//div')->text()); |
} |
|
public function testAddHtmlContentInvalidBaseTag() |
{ |
$crawler = new Crawler(null, 'http://symfony.com'); |
|
$crawler->addHtmlContent('<html><head><base target="_top"></head><a href="/contact"></a></html>', 'UTF-8'); |
|
$this->assertEquals('http://symfony.com/contact', current($crawler->filterXPath('//a')->links())->getUri(), '->addHtmlContent() correctly handles a non-existent base tag href attribute'); |
} |
|
public function testAddHtmlContentUnsupportedCharset() |
{ |
$crawler = new Crawler(); |
$crawler->addHtmlContent(file_get_contents(__DIR__.'/Fixtures/windows-1250.html'), 'Windows-1250'); |
|
$this->assertEquals('Žťčýů', $crawler->filterXPath('//p')->text()); |
} |
|
/** |
* @requires extension mbstring |
*/ |
public function testAddHtmlContentCharsetGbk() |
{ |
$crawler = new Crawler(); |
//gbk encode of <html><p>中文</p></html> |
$crawler->addHtmlContent(base64_decode('PGh0bWw+PHA+1tDOxDwvcD48L2h0bWw+'), 'gbk'); |
|
$this->assertEquals('中文', $crawler->filterXPath('//p')->text()); |
} |
|
public function testAddHtmlContentWithErrors() |
{ |
$internalErrors = libxml_use_internal_errors(true); |
|
$crawler = new Crawler(); |
$crawler->addHtmlContent(<<<'EOF' |
<!DOCTYPE html> |
<html> |
<head> |
</head> |
<body> |
<nav><a href="#"><a href="#"></nav> |
</body> |
</html> |
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); |
} |
|
public function testAddXmlContent() |
{ |
$crawler = new Crawler(); |
$crawler->addXmlContent('<html><div class="foo"></div></html>', 'UTF-8'); |
|
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addXmlContent() adds nodes from an XML string'); |
} |
|
public function testAddXmlContentCharset() |
{ |
$crawler = new Crawler(); |
$crawler->addXmlContent('<html><div class="foo">Tiếng Việt</div></html>', 'UTF-8'); |
|
$this->assertEquals('Tiếng Việt', $crawler->filterXPath('//div')->text()); |
} |
|
public function testAddXmlContentWithErrors() |
{ |
$internalErrors = libxml_use_internal_errors(true); |
|
$crawler = new Crawler(); |
$crawler->addXmlContent(<<<'EOF' |
<!DOCTYPE html> |
<html> |
<head> |
</head> |
<body> |
<nav><a href="#"><a href="#"></nav> |
</body> |
</html> |
EOF |
, 'UTF-8'); |
|
$this->assertTrue(count(libxml_get_errors()) > 1); |
|
libxml_clear_errors(); |
libxml_use_internal_errors($internalErrors); |
} |
|
public function testAddContent() |
{ |
$crawler = new Crawler(); |
$crawler->addContent('<html><div class="foo"></html>', '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('<html><div class="foo"></html>', '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('<html><div class="foo"></html>'); |
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addContent() uses text/html as the default type'); |
|
$crawler = new Crawler(); |
$crawler->addContent('<html><div class="foo"></div></html>', '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('<html><div class="foo"></div></html>', '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('<html><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><span>中文</span></html>'); |
$this->assertEquals('中文', $crawler->filterXPath('//span')->text(), '->addContent() guess wrong charset'); |
} |
|
/** |
* @requires extension iconv |
*/ |
public function testAddContentNonUtf8() |
{ |
$crawler = new Crawler(); |
$crawler->addContent(iconv('UTF-8', 'SJIS', '<html><head><meta charset="Shift_JIS"></head><body>日本語</body></html>')); |
$this->assertEquals('日本語', $crawler->filterXPath('//body')->text(), '->addContent() can recognize "Shift_JIS" in html5 meta charset tag'); |
} |
|
public function testAddDocument() |
{ |
$crawler = new Crawler(); |
$crawler->addDocument($this->createDomDocument()); |
|
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addDocument() adds nodes from a \DOMDocument'); |
} |
|
public function testAddNodeList() |
{ |
$crawler = new Crawler(); |
$crawler->addNodeList($this->createNodeList()); |
|
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addNodeList() adds nodes from a \DOMNodeList'); |
} |
|
public function testAddNodes() |
{ |
$list = array(); |
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'); |
} |
|
public function testAddNode() |
{ |
$crawler = new Crawler(); |
$crawler->addNode($this->createNodeList()->item(0)); |
|
$this->assertEquals('foo', $crawler->filterXPath('//div')->attr('class'), '->addNode() adds nodes from a \DOMNode'); |
} |
|
public function testClear() |
{ |
$doc = new \DOMDocument(); |
$node = $doc->createElement('test'); |
|
$crawler = new Crawler($node); |
$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 testIteration() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//li'); |
|
$this->assertInstanceOf('Traversable', $crawler); |
$this->assertContainsOnlyInstancesOf('DOMElement', iterator_to_array($crawler), 'Iterating a Crawler gives DOMElement instances'); |
} |
|
public function testSlice() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//ul[1]/li'); |
$this->assertNotSame($crawler->slice(), $crawler, '->slice() returns a new instance of a crawler'); |
$this->assertInstanceOf('Symfony\\Component\\DomCrawler\\Crawler', $crawler->slice(), '->slice() returns a new instance of a crawler'); |
|
$this->assertCount(3, $crawler->slice(), '->slice() does not slice the nodes in the list if any param is entered'); |
$this->assertCount(1, $crawler->slice(1, 1), '->slice() slices the nodes in the list'); |
} |
|
public function testReduce() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//ul[1]/li'); |
$nodes = $crawler->reduce(function ($node, $i) { |
return $i !== 1; |
}); |
$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('<html><div non-empty-attr="sample value" empty-attr=""></div></html>', '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 testNodeName() |
{ |
$this->assertEquals('li', $this->createTestCrawler()->filterXPath('//li')->nodeName(), '->nodeName() returns the node name of the first element of the node list'); |
|
try { |
$this->createTestCrawler()->filterXPath('//ol')->nodeName(); |
$this->fail('->nodeName() throws an \InvalidArgumentException if the node list is empty'); |
} catch (\InvalidArgumentException $e) { |
$this->assertTrue(true, '->nodeName() throws an \InvalidArgumentException if the node list is empty'); |
} |
} |
|
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('<img alt="Bar">', $this->createTestCrawler()->filterXPath('//a[5]')->html()); |
$this->assertEquals('<input type="text" value="TextValue" name="TextName"><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"></button>', 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'); |
} |
|
public function testFilterXpathComplexQueries() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//body'); |
|
$this->assertCount(0, $crawler->filterXPath('/input')); |
$this->assertCount(0, $crawler->filterXPath('/body')); |
$this->assertCount(1, $crawler->filterXPath('./body')); |
$this->assertCount(1, $crawler->filterXPath('.//body')); |
$this->assertCount(5, $crawler->filterXPath('.//input')); |
$this->assertCount(4, $crawler->filterXPath('//form')->filterXPath('//button | //input')); |
$this->assertCount(1, $crawler->filterXPath('body')); |
$this->assertCount(6, $crawler->filterXPath('//button | //input')); |
$this->assertCount(1, $crawler->filterXPath('//body')); |
$this->assertCount(1, $crawler->filterXPath('descendant-or-self::body')); |
$this->assertCount(1, $crawler->filterXPath('//div[@id="parent"]')->filterXPath('./div'), 'A child selection finds only the current div'); |
$this->assertCount(3, $crawler->filterXPath('//div[@id="parent"]')->filterXPath('descendant::div'), 'A descendant selector matches the current div and its child'); |
$this->assertCount(3, $crawler->filterXPath('//div[@id="parent"]')->filterXPath('//div'), 'A descendant selector matches the current div and its child'); |
$this->assertCount(5, $crawler->filterXPath('(//a | //div)//img')); |
$this->assertCount(7, $crawler->filterXPath('((//a | //div)//img | //ul)')); |
$this->assertCount(7, $crawler->filterXPath('( ( //a | //div )//img | //ul )')); |
$this->assertCount(1, $crawler->filterXPath("//a[./@href][((./@id = 'Klausi|Claudiu' or normalize-space(string(.)) = 'Klausi|Claudiu' or ./@title = 'Klausi|Claudiu' or ./@rel = 'Klausi|Claudiu') or .//img[./@alt = 'Klausi|Claudiu'])]")); |
} |
|
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'); |
|
$crawler = $this->createTestCrawler(); |
$this->assertCount(3, $crawler->filterXPath('//body')->filterXPath('//button')->parents(), '->filterXpath() preserves parents when chained'); |
} |
|
public function testFilterRemovesDuplicates() |
{ |
$crawler = $this->createTestCrawler()->filter('html, body')->filter('li'); |
$this->assertCount(6, $crawler, 'The crawler removes duplicates when filtering.'); |
} |
|
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()); |
} |
|
public function testFilterXPathWithFakeRoot() |
{ |
$crawler = $this->createTestCrawler(); |
$this->assertCount(0, $crawler->filterXPath('.'), '->filterXPath() returns an empty result if the XPath references the fake root node'); |
$this->assertCount(0, $crawler->filterXPath('self::*'), '->filterXPath() returns an empty result if the XPath references the fake root node'); |
$this->assertCount(0, $crawler->filterXPath('self::_root'), '->filterXPath() returns an empty result if the XPath references the fake root node'); |
} |
|
/** @group legacy */ |
public function testLegacyFilterXPathWithFakeRoot() |
{ |
$crawler = $this->createTestCrawler(); |
$this->assertCount(0, $crawler->filterXPath('/_root'), '->filterXPath() returns an empty result if the XPath references the fake root node'); |
|
$crawler = $this->createTestCrawler()->filterXPath('//body'); |
$this->assertCount(1, $crawler->filterXPath('/_root/body')); |
} |
|
public function testFilterXPathWithAncestorAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//form'); |
|
$this->assertCount(0, $crawler->filterXPath('ancestor::*'), 'The fake root node has no ancestor nodes'); |
} |
|
public function testFilterXPathWithAncestorOrSelfAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//form'); |
|
$this->assertCount(0, $crawler->filterXPath('ancestor-or-self::*'), 'The fake root node has no ancestor nodes'); |
} |
|
public function testFilterXPathWithAttributeAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//form'); |
|
$this->assertCount(0, $crawler->filterXPath('attribute::*'), 'The fake root node has no attribute nodes'); |
} |
|
public function testFilterXPathWithAttributeAxisAfterElementAxis() |
{ |
$this->assertCount(3, $this->createTestCrawler()->filterXPath('//form/button/attribute::*'), '->filterXPath() handles attribute axes properly when they are preceded by an element filtering axis'); |
} |
|
public function testFilterXPathWithChildAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//div[@id="parent"]'); |
|
$this->assertCount(1, $crawler->filterXPath('child::div'), 'A child selection finds only the current div'); |
} |
|
public function testFilterXPathWithFollowingAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//a'); |
|
$this->assertCount(0, $crawler->filterXPath('following::div'), 'The fake root node has no following nodes'); |
} |
|
public function testFilterXPathWithFollowingSiblingAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//a'); |
|
$this->assertCount(0, $crawler->filterXPath('following-sibling::div'), 'The fake root node has no following nodes'); |
} |
|
public function testFilterXPathWithNamespaceAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//button'); |
|
$this->assertCount(0, $crawler->filterXPath('namespace::*'), 'The fake root node has no namespace nodes'); |
} |
|
public function testFilterXPathWithNamespaceAxisAfterElementAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//div[@id="parent"]/namespace::*'); |
|
$this->assertCount(0, $crawler->filterXPath('namespace::*'), 'Namespace axes cannot be requested'); |
} |
|
public function testFilterXPathWithParentAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//button'); |
|
$this->assertCount(0, $crawler->filterXPath('parent::*'), 'The fake root node has no parent nodes'); |
} |
|
public function testFilterXPathWithPrecedingAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//form'); |
|
$this->assertCount(0, $crawler->filterXPath('preceding::*'), 'The fake root node has no preceding nodes'); |
} |
|
public function testFilterXPathWithPrecedingSiblingAxis() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//form'); |
|
$this->assertCount(0, $crawler->filterXPath('preceding-sibling::*'), 'The fake root node has no preceding nodes'); |
} |
|
public function testFilterXPathWithSelfAxes() |
{ |
$crawler = $this->createTestCrawler()->filterXPath('//a'); |
|
$this->assertCount(0, $crawler->filterXPath('self::a'), 'The fake root node has no "real" element name'); |
$this->assertCount(0, $crawler->filterXPath('self::a/img'), 'The fake root node has no "real" element name'); |
$this->assertCount(10, $crawler->filterXPath('self::*/a')); |
} |
|
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() |
{ |
$crawler = $this->createTestXmlCrawler()->filter('yt|accessControl'); |
$this->assertCount(2, $crawler, '->filter() automatically registers namespaces'); |
} |
|
public function testFilterWithMultipleNamespaces() |
{ |
$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('<?xml version="1.0" encoding="UTF-8"?> |
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> |
<url> |
<loc>http://localhost/foo</loc> |
<changefreq>weekly</changefreq> |
<priority>0.5</priority> |
<lastmod>2012-11-16</lastmod> |
</url> |
<url> |
<loc>http://localhost/bar</loc> |
<changefreq>weekly</changefreq> |
<priority>0.5</priority> |
<lastmod>2012-11-16</lastmod> |
</url> |
</urlset> |
'); |
|
$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 testSelectButtonWithSingleQuotesInNameAttribute() |
{ |
$html = <<<'HTML' |
<!DOCTYPE html> |
<html lang="en"> |
<body> |
<div id="action"> |
<a href="/index.php?r=site/login">Login</a> |
</div> |
<form id="login-form" action="/index.php?r=site/login" method="post"> |
<button type="submit" name="Click 'Here'">Submit</button> |
</form> |
</body> |
</html> |
HTML; |
|
$crawler = new Crawler($html); |
|
$this->assertCount(1, $crawler->selectButton('Click \'Here\'')); |
} |
|
public function testSelectButtonWithDoubleQuotesInNameAttribute() |
{ |
$html = <<<'HTML' |
<!DOCTYPE html> |
<html lang="en"> |
<body> |
<div id="action"> |
<a href="/index.php?r=site/login">Login</a> |
</div> |
<form id="login-form" action="/index.php?r=site/login" method="post"> |
<button type="submit" name='Click "Here"'>Submit</button> |
</form> |
</body> |
</html> |
HTML; |
|
$crawler = new Crawler($html); |
|
$this->assertCount(1, $crawler->selectButton('Click "Here"')); |
} |
|
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'); |
} |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage The selected node should be instance of DOMElement |
*/ |
public function testInvalidLink() |
{ |
$crawler = $this->createTestCrawler('http://example.com/bar/'); |
$crawler->filterXPath('//li/text()')->link(); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage The selected node should be instance of DOMElement |
*/ |
public function testInvalidLinks() |
{ |
$crawler = $this->createTestCrawler('http://example.com/bar/'); |
$crawler->filterXPath('//li/text()')->link(); |
} |
|
public function testSelectLinkAndLinkFiltered() |
{ |
$html = <<<'HTML' |
<!DOCTYPE html> |
<html lang="en"> |
<body> |
<div id="action"> |
<a href="/index.php?r=site/login">Login</a> |
</div> |
<form id="login-form" action="/index.php?r=site/login" method="post"> |
<button type="submit">Submit</button> |
</form> |
</body> |
</html> |
HTML; |
|
$crawler = new Crawler($html); |
$filtered = $crawler->filterXPath("descendant-or-self::*[@id = 'login-form']"); |
|
$this->assertCount(0, $filtered->selectLink('Login')); |
$this->assertCount(1, $filtered->selectButton('Submit')); |
|
$filtered = $crawler->filterXPath("descendant-or-self::*[@id = 'action']"); |
|
$this->assertCount(1, $filtered->selectLink('Login')); |
$this->assertCount(0, $filtered->selectButton('Submit')); |
|
$this->assertCount(1, $crawler->selectLink('Login')->selectLink('Login')); |
$this->assertCount(1, $crawler->selectButton('Submit')->selectButton('Submit')); |
} |
|
public function testChaining() |
{ |
$crawler = new Crawler('<div name="a"><div name="b"><div name="c"></div></div></div>'); |
|
$this->assertEquals('a', $crawler->filterXPath('//div')->filterXPath('div')->filterXPath('div')->attr('name')); |
} |
|
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'); |
} |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage The selected node should be instance of DOMElement |
*/ |
public function testInvalidForm() |
{ |
$crawler = $this->createTestCrawler('http://example.com/bar/'); |
$crawler->filterXPath('//li/text()')->form(); |
} |
|
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('<p></p>'); |
$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'); |
} 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'); |
} |
} |
|
/** |
* @dataProvider getBaseTagData |
*/ |
public function testBaseTag($baseValue, $linkValue, $expectedUri, $currentUri = null, $description = null) |
{ |
$crawler = new Crawler('<html><base href="'.$baseValue.'"><a href="'.$linkValue.'"></a></html>', $currentUri); |
$this->assertEquals($expectedUri, $crawler->filterXPath('//a')->link()->getUri(), $description); |
} |
|
public function getBaseTagData() |
{ |
return array( |
array('http://base.com', 'link', 'http://base.com/link'), |
array('//base.com', 'link', 'https://base.com/link', 'https://domain.com', '<base> tag can use a schema-less URL'), |
array('path/', 'link', 'https://domain.com/path/link', 'https://domain.com', '<base> tag can set a path'), |
array('http://base.com', '#', 'http://base.com#', 'http://domain.com/path/link', '<base> tag does work with links to an anchor'), |
array('http://base.com', '', 'http://base.com', 'http://domain.com/path/link', '<base> tag does work with empty links'), |
); |
} |
|
/** |
* @dataProvider getBaseTagWithFormData |
*/ |
public function testBaseTagWithForm($baseValue, $actionValue, $expectedUri, $currentUri = null, $description = null) |
{ |
$crawler = new Crawler('<html><base href="'.$baseValue.'"><form method="post" action="'.$actionValue.'"><button type="submit" name="submit"/></form></html>', $currentUri); |
$this->assertEquals($expectedUri, $crawler->filterXPath('//button')->form()->getUri(), $description); |
} |
|
public function getBaseTagWithFormData() |
{ |
return array( |
array('https://base.com/', 'link/', 'https://base.com/link/', 'https://base.com/link/', '<base> tag does work with a path and relative form action'), |
array('/basepath', '/registration', 'http://domain.com/registration', 'http://domain.com/registration', '<base> tag does work with a path and form action'), |
array('/basepath', '', 'http://domain.com/registration', 'http://domain.com/registration', '<base> tag does work with a path and empty form action'), |
array('http://base.com/', '/registration', 'http://base.com/registration', 'http://domain.com/registration', '<base> tag does work with a URL and form action'), |
array('http://base.com', '', 'http://domain.com/path/form', 'http://domain.com/path/form', '<base> tag does work with a URL and an empty form action'), |
array('http://base.com/path', '/registration', 'http://base.com/registration', 'http://domain.com/path/form', '<base> tag does work with a URL and form action'), |
); |
} |
|
public function testCountOfNestedElements() |
{ |
$crawler = new Crawler('<html><body><ul><li>List item 1<ul><li>Sublist item 1</li><li>Sublist item 2</ul></li></ul></body></html>'); |
|
$this->assertCount(1, $crawler->filter('li:contains("List item 1")')); |
} |
|
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"s Bar"/></a> |
<a href="/bar"><img alt="\' Fabien"s Bar"/></a> |
|
<a href="?get=param">GetLink</a> |
|
<a href="/example">Klausi|Claudiu</a> |
|
<form action="foo" id="FooFormId"> |
<input type="text" value="TextValue" name="TextName" /> |
<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> |
|
<input type="submit" value="FooBarValue" name="FooBarName" form="FooFormId" /> |
<input type="text" value="FooTextValue" name="FooTextName" form="FooFormId" /> |
|
<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> |
<div id="parent"> |
<div id="child"></div> |
<div id="child2" xmlns:foo="http://example.com"></div> |
</div> |
<div id="sibling"><img /></div> |
</body> |
</html> |
'); |
|
return new Crawler($dom, $uri); |
} |
|
protected function createTestXmlCrawler($uri = null) |
{ |
$xml = '<?xml version="1.0" encoding="UTF-8"?> |
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" xmlns:yt="http://gdata.youtube.com/schemas/2007"> |
<id>tag:youtube.com,2008:video:kgZRZmEc9j4</id> |
<yt:accessControl action="comment" permission="allowed"/> |
<yt:accessControl action="videoRespond" permission="moderated"/> |
<media:group> |
<media:title type="plain">Chordates - CrashCourse Biology #24</media:title> |
<yt:aspectRatio>widescreen</yt:aspectRatio> |
</media:group> |
<media:category label="Music" scheme="http://gdata.youtube.com/schemas/2007/categories.cat">Music</media:category> |
</entry>'; |
|
return new Crawler($xml, $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'); |
} |
} |
/vendor/symfony/dom-crawler/Tests/Field/ChoiceFormFieldTest.php |
@@ -0,0 +1,404 @@ |
<?php |
|
/* |
* This file is part of the Symfony package. |
* |
* (c) Fabien Potencier <fabien@symfony.com> |
* |
* 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'); |
|
$node = $this->createNode('select', '', array('multiple' => '')); |
$field = new ChoiceFormField($node); |
|
$this->assertTrue($field->isMultiple(), '->isMultiple() returns true for selects with an empty 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 testSelectWithEmptyBooleanAttribute() |
{ |
$node = $this->createSelectNode(array('foo' => false, 'bar' => true), array(), ''); |
$field = new ChoiceFormField($node); |
|
$this->assertEquals('bar', $field->getValue()); |
} |
|
public function testSelectIsDisabled() |
{ |
$node = $this->createSelectNode(array('foo' => false, 'bar' => true), array('disabled' => 'disabled')); |
$field = new ChoiceFormField($node); |
|
$this->assertTrue($field->isDisabled(), '->isDisabled() returns true for selects with a disabled attribute'); |
} |
|
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 testRadioButtonsWithEmptyBooleanAttribute() |
{ |
$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' => '')); |
$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'); |
} |
|
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); |
$node = $this->createNode('input', '', array('type' => 'radio', 'name' => 'name', 'value' => 'baz', 'disabled' => '')); |
$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()); |
|
$field->select('baz'); |
$this->assertEquals('baz', $field->getValue(), '->getValue() returns the value attribute of the selected radio button'); |
$this->assertTrue($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 \DOMElement('input')); |
$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('on', $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 testCheckboxWithEmptyBooleanAttribute() |
{ |
$node = $this->createNode('input', '', array('type' => 'checkbox', 'name' => 'name', 'value' => 'foo', 'checked' => '')); |
$field = new ChoiceFormField($node); |
|
$this->assertTrue($field->hasValue(), '->hasValue() returns true when the checkbox is checked'); |
$this->assertEquals('foo', $field->getValue()); |
} |
|
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('on', $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('on', $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); |
$this->assertEquals('foo', $field->getValue()); |
|
$node = $this->createSelectNodeWithEmptyOption(array('foo' => false, 'bar' => true)); |
$field = new ChoiceFormField($node); |
$this->assertEquals('bar', $field->getValue()); |
$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.'); |
} |
|
public function testSelectWithEmptyValue() |
{ |
$node = $this->createSelectNodeWithEmptyOption(array('' => true, 'Female' => false, 'Male' => false)); |
$field = new ChoiceFormField($node); |
|
$this->assertSame('', $field->getValue()); |
} |
|
protected function createSelectNode($options, $attributes = array(), $selectedAttrText = 'selected') |
{ |
$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', $selectedAttrText); |
} |
$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; |
} |
} |
/vendor/symfony/dom-crawler/Tests/FormTest.php |
@@ -0,0 +1,941 @@ |
<?php |
|
/* |
* This file is part of the Symfony package. |
* |
* (c) Fabien Potencier <fabien@symfony.com> |
* |
* 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 PHPUnit\Framework\TestCase; |
use Symfony\Component\DomCrawler\Form; |
use Symfony\Component\DomCrawler\FormFieldRegistry; |
|
class FormTest extends 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(' |
<html> |
<input type="submit" /> |
<form> |
<input type="foo" /> |
</form> |
<button /> |
</html> |
'); |
|
$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(' |
<html> |
<form id="bar"> |
<input type="submit" form="nonexistent" /> |
</form> |
<input type="text" form="nonexistent" /> |
<button /> |
</html> |
'); |
|
$nodes = $dom->getElementsByTagName('input'); |
|
$form = new Form($nodes->item(0), 'http://example.com'); |
$form = new Form($nodes->item(1), 'http://example.com'); |
} |
|
public function testConstructorLoadsOnlyFieldsOfTheRightForm() |
{ |
$dom = $this->createTestMultipleForm(); |
|
$nodes = $dom->getElementsByTagName('form'); |
$buttonElements = $dom->getElementsByTagName('button'); |
|
$form = new Form($nodes->item(0), 'http://example.com'); |
$this->assertCount(3, $form->all()); |
|
$form = new Form($buttonElements->item(1), 'http://example.com'); |
$this->assertCount(5, $form->all()); |
} |
|
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('<form> |
<input type="text" name="foo[4]" value="foo" disabled="disabled" /> |
<input type="text" name="foo" value="foo" disabled="disabled" /> |
<input type="text" name="foo[2]" value="foo" disabled="disabled" /> |
<input type="text" name="foo[]" value="foo" disabled="disabled" /> |
<input type="text" name="bar[foo][]" value="foo" disabled="disabled" /> |
<input type="text" name="bar[foo][foobar]" value="foo" disabled="disabled" /> |
<input type="submit" /> |
</form> |
'); |
|
$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('<form>'.$form.'</form>'); |
$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', |
'<input type="text" value="foo" /> |
<input type="submit" />', |
array(), |
), |
array( |
'does not take into account input fields with an empty name attribute value', |
'<input type="text" name="" value="foo" /> |
<input type="submit" />', |
array(), |
), |
array( |
'takes into account disabled input fields', |
'<input type="text" name="foo" value="foo" disabled="disabled" /> |
<input type="submit" />', |
array('foo' => array('InputFormField', 'foo')), |
), |
array( |
'appends the submitted button value', |
'<input type="submit" name="bar" value="bar" />', |
array('bar' => array('InputFormField', 'bar')), |
), |
array( |
'appends the submitted button value for Button element', |
'<button type="submit" name="bar" value="bar">Bar</button>', |
array('bar' => array('InputFormField', 'bar')), |
), |
array( |
'appends the submitted button value but not other submit buttons', |
'<input type="submit" name="bar" value="bar" /> |
<input type="submit" name="foobar" value="foobar" />', |
array('foobar' => array('InputFormField', 'foobar')), |
), |
array( |
'turns an image input into x and y fields', |
'<input type="image" name="bar" />', |
array('bar.x' => array('InputFormField', '0'), 'bar.y' => array('InputFormField', '0')), |
), |
array( |
'returns textareas', |
'<textarea name="foo">foo</textarea> |
<input type="submit" />', |
array('foo' => array('TextareaFormField', 'foo')), |
), |
array( |
'returns inputs', |
'<input type="text" name="foo" value="foo" /> |
<input type="submit" />', |
array('foo' => array('InputFormField', 'foo')), |
), |
array( |
'returns checkboxes', |
'<input type="checkbox" name="foo" value="foo" checked="checked" /> |
<input type="submit" />', |
array('foo' => array('ChoiceFormField', 'foo')), |
), |
array( |
'returns not-checked checkboxes', |
'<input type="checkbox" name="foo" value="foo" /> |
<input type="submit" />', |
array('foo' => array('ChoiceFormField', false)), |
), |
array( |
'returns radio buttons', |
'<input type="radio" name="foo" value="foo" /> |
<input type="radio" name="foo" value="bar" checked="bar" /> |
<input type="submit" />', |
array('foo' => array('ChoiceFormField', 'bar')), |
), |
array( |
'returns file inputs', |
'<input type="file" name="foo" /> |
<input type="submit" />', |
array('foo' => array('FileFormField', array('name' => '', 'type' => '', 'tmp_name' => '', 'error' => 4, 'size' => 0))), |
), |
); |
} |
|
public function testGetFormNode() |
{ |
$dom = new \DOMDocument(); |
$dom->loadHTML('<html><form><input type="submit" /></form></html>'); |
|
$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('<html><form name="my_form"><input type="submit" /></form></html>'); |
|
$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('<form><input type="submit" /></form>'); |
$this->assertEquals('GET', $form->getMethod(), '->getMethod() returns get if no method is defined'); |
|
$form = $this->createForm('<form method="post"><input type="submit" /></form>'); |
$this->assertEquals('POST', $form->getMethod(), '->getMethod() returns the method attribute value of the form'); |
|
$form = $this->createForm('<form method="post"><input type="submit" /></form>', 'put'); |
$this->assertEquals('PUT', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided'); |
|
$form = $this->createForm('<form method="post"><input type="submit" /></form>', 'delete'); |
$this->assertEquals('DELETE', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided'); |
|
$form = $this->createForm('<form method="post"><input type="submit" /></form>', 'patch'); |
$this->assertEquals('PATCH', $form->getMethod(), '->getMethod() returns the method defined in the constructor if provided'); |
} |
|
public function testGetSetValue() |
{ |
$form = $this->createForm('<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>'); |
|
$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 testDisableValidation() |
{ |
$form = $this->createForm('<form> |
<select name="foo[bar]"> |
<option value="bar">bar</option> |
</select> |
<select name="foo[baz]"> |
<option value="foo">foo</option> |
</select> |
<input type="submit" /> |
</form>'); |
|
$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('<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>'); |
unset($form['foo']); |
$this->assertFalse(isset($form['foo']), '->offsetUnset() removes a field'); |
} |
|
public function testOffsetExists() |
{ |
$form = $this->createForm('<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>'); |
|
$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('<form><input type="text" name="foo[bar]" value="foo" /><input type="text" name="bar" value="bar" /><select multiple="multiple" name="baz[]"></select><input type="submit" /></form>'); |
$this->assertEquals(array('foo[bar]' => 'foo', 'bar' => 'bar', 'baz' => array()), $form->getValues(), '->getValues() returns all form field values'); |
|
$form = $this->createForm('<form><input type="checkbox" name="foo" value="foo" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include not-checked checkboxes'); |
|
$form = $this->createForm('<form><input type="file" name="foo" value="foo" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include file input fields'); |
|
$form = $this->createForm('<form><input type="text" name="foo" value="foo" disabled="disabled" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('bar' => 'bar'), $form->getValues(), '->getValues() does not include disabled fields'); |
} |
|
public function testSetValues() |
{ |
$form = $this->createForm('<form><input type="checkbox" name="foo" value="foo" checked="checked" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$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><select multiple="multiple" name="multi"><option value="foo">foo</option><option value="bar">bar</option></select><input type="submit" /></form>'); |
$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('<form><input type="text" name="foo[bar]" value="foo" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('foo' => array('bar' => 'foo'), 'bar' => 'bar'), $form->getPhpValues(), '->getPhpValues() converts keys with [] to arrays'); |
|
$form = $this->createForm('<form><input type="text" name="fo.o[ba.r]" value="foo" /><input type="text" name="ba r" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('fo.o' => array('ba.r' => 'foo'), 'ba r' => 'bar'), $form->getPhpValues(), '->getPhpValues() preserves periods and spaces in names'); |
|
$form = $this->createForm('<form><input type="text" name="fo.o[ba.r][]" value="foo" /><input type="text" name="fo.o[ba.r][ba.z]" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array('fo.o' => array('ba.r' => array('foo', 'ba.z' => 'bar'))), $form->getPhpValues(), '->getPhpValues() preserves periods and spaces in names recursively'); |
|
$form = $this->createForm('<form><input type="text" name="foo[bar]" value="foo" /><input type="text" name="bar" value="bar" /><select multiple="multiple" name="baz[]"></select><input type="submit" /></form>'); |
$this->assertEquals(array('foo' => array('bar' => 'foo'), 'bar' => 'bar'), $form->getPhpValues(), "->getPhpValues() doesn't return empty values"); |
} |
|
public function testGetFiles() |
{ |
$form = $this->createForm('<form><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$this->assertEquals(array(), $form->getFiles(), '->getFiles() returns an empty array if method is get'); |
|
$form = $this->createForm('<form method="post"><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$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('<form method="post"><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>', '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('<form method="post"><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>', '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('<form method="post"><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>', '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('<form method="post"><input type="file" name="foo[bar]" disabled="disabled" /><input type="submit" /></form>'); |
$this->assertEquals(array(), $form->getFiles(), '->getFiles() does not include disabled file fields'); |
} |
|
public function testGetPhpFiles() |
{ |
$form = $this->createForm('<form method="post"><input type="file" name="foo[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$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('<form method="post"><input type="file" name="f.o o[bar]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$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('<form method="post"><input type="file" name="f.o o[bar][ba.z]" /><input type="file" name="f.o o[bar][]" /><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$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('<form method="post" action="foo.php"><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
|
$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('<form action="#foo"><input type="submit" /></form>', null, 'http://example.com/id/123'); |
|
$this->assertEquals('http://example.com/id/123#foo', $form->getUri()); |
} |
|
public function testGetUriActionAbsolute() |
{ |
$formHtml = '<form id="login_form" action="https://login.foo.com/login.php?login_attempt=1" method="POST"><input type="text" name="foo" value="foo" /><input type="submit" /></form>'; |
|
$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('<form action="foo"><input type="submit" /></form>', null, 'http://localhost/foo/'); |
$this->assertEquals('http://localhost/foo/foo', $form->getUri(), '->getUri() returns absolute URIs'); |
|
$form = $this->createForm('<form action="/foo"><input type="submit" /></form>', null, 'http://localhost/foo/'); |
$this->assertEquals('http://localhost/foo', $form->getUri(), '->getUri() returns absolute URIs'); |
} |
|
public function testGetUriWithOnlyQueryString() |
{ |
$form = $this->createForm('<form action="?get=param"><input type="submit" /></form>', 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('<form><input type="submit" /></form>', 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', |
'<form action="/foo"><input type="submit" /></form>', |
array(), |
'/foo', |
), |
array( |
'appends the form values if the method is get', |
'<form action="/foo"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo?foo=foo', |
), |
array( |
'appends the form values and merges the submitted values', |
'<form action="/foo"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array('foo' => 'bar'), |
'/foo?foo=bar', |
), |
array( |
'does not append values if the method is post', |
'<form action="/foo" method="post"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo', |
), |
array( |
'does not append values if the method is patch', |
'<form action="/foo" method="post"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo', |
'PUT', |
), |
array( |
'does not append values if the method is delete', |
'<form action="/foo" method="post"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo', |
'DELETE', |
), |
array( |
'does not append values if the method is put', |
'<form action="/foo" method="post"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo', |
'PATCH', |
), |
array( |
'appends the form values to an existing query string', |
'<form action="/foo?bar=bar"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo?bar=bar&foo=foo', |
), |
array( |
'replaces query values with the form values', |
'<form action="/foo?bar=bar"><input type="text" name="bar" value="foo" /><input type="submit" /></form>', |
array(), |
'/foo?bar=foo', |
), |
array( |
'returns an empty URI if the action is empty', |
'<form><input type="submit" /></form>', |
array(), |
'/', |
), |
array( |
'appends the form values even if the action is empty', |
'<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/?foo=foo', |
), |
array( |
'chooses the path if the action attribute value is a sharp (#)', |
'<form action="#" method="post"><input type="text" name="foo" value="foo" /><input type="submit" /></form>', |
array(), |
'/#', |
), |
); |
} |
|
public function testHas() |
{ |
$form = $this->createForm('<form method="post"><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
|
$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 method="post"><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
$form->remove('bar'); |
$this->assertFalse($form->has('bar'), '->remove() removes a field'); |
} |
|
public function testGet() |
{ |
$form = $this->createForm('<form method="post"><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
|
$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('<form method="post"><input type="text" name="bar" value="bar" /><input type="submit" /></form>'); |
|
$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(' |
<html> |
<form> |
<input type="foo" /> |
</form> |
</html> |
'); |
|
$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'); |
} |
|
public function testTypeAttributeIsCaseInsensitive() |
{ |
$form = $this->createForm('<form method="post"><input type="IMAGE" name="example" /></form>'); |
$this->assertTrue($form->has('example.x'), '->has() returns true if the image input was correctly turned into an x and a y fields'); |
$this->assertTrue($form->has('example.y'), '->has() returns true if the image input was correctly turned into an x and a y fields'); |
} |
|
public function testFormFieldRegistryAcceptAnyNames() |
{ |
$field = $this->getFormFieldMock('[t:dbt%3adate;]data_daterange_enddate_value'); |
|
$registry = new FormFieldRegistry(); |
$registry->add($field); |
$this->assertEquals($field, $registry->get('[t:dbt%3adate;]data_daterange_enddate_value')); |
$registry->set('[t:dbt%3adate;]data_daterange_enddate_value', null); |
|
$form = $this->createForm('<form><input type="text" name="[t:dbt%3adate;]data_daterange_enddate_value" value="bar" /><input type="submit" /></form>'); |
$form['[t:dbt%3adate;]data_daterange_enddate_value'] = 'bar'; |
|
$registry->remove('[t:dbt%3adate;]data_daterange_enddate_value'); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testFormFieldRegistryGetThrowAnExceptionWhenTheFieldDoesNotExist() |
{ |
$registry = new FormFieldRegistry(); |
$registry->get('foo'); |
} |
|
/** |
* @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', |
), |
)); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage Cannot set value on a compound field "foo[bar]". |
*/ |
public function testFormRegistrySetValueOnCompoundField() |
{ |
$registry = new FormFieldRegistry(); |
$registry->add($this->getFormFieldMock('foo[bar][baz]')); |
|
$registry->set('foo[bar]', 'fbb'); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage Unreachable field "0" |
*/ |
public function testFormRegistrySetArrayOnNotCompoundField() |
{ |
$registry = new FormFieldRegistry(); |
$registry->add($this->getFormFieldMock('bar')); |
|
$registry->set('bar', array('baz')); |
} |
|
public function testDifferentFieldTypesWithSameName() |
{ |
$dom = new \DOMDocument(); |
$dom->loadHTML(' |
<html> |
<body> |
<form action="/"> |
<input type="hidden" name="option" value="default"> |
<input type="radio" name="option" value="A"> |
<input type="radio" name="option" value="B"> |
<input type="hidden" name="settings[1]" value="0"> |
<input type="checkbox" name="settings[1]" value="1" id="setting-1"> |
<button>klickme</button> |
</form> |
</body> |
</html> |
'); |
$form = new Form($dom->getElementsByTagName('form')->item(0), 'http://example.com'); |
|
$this->assertInstanceOf('Symfony\Component\DomCrawler\Field\ChoiceFormField', $form->get('option')); |
} |
|
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('<html>'.$form.'</html>'); |
|
$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(' |
<html> |
<h1>Hello form</h1> |
<form id="form-1" action="" method="POST"> |
<div><input type="checkbox" name="apples[]" value="1" checked /></div> |
<input form="form_2" type="checkbox" name="oranges[]" value="1" checked /> |
<div><label></label><input form="form-1" type="hidden" name="form_name" value="form-1" /></div> |
<input form="form-1" type="submit" name="button_1" value="Capture fields" /> |
<button form="form_2" type="submit" name="button_2">Submit form_2</button> |
</form> |
<input form="form-1" type="checkbox" name="apples[]" value="2" checked /> |
<form id="form_2" action="" method="POST"> |
<div><div><input type="checkbox" name="oranges[]" value="2" checked /> |
<input type="checkbox" name="oranges[]" value="3" checked /></div></div> |
<input form="form_2" type="hidden" name="form_name" value="form_2" /> |
<input form="form-1" type="hidden" name="outer_field" value="success" /> |
<button form="form-1" type="submit" name="button_3">Submit from outside the form</button> |
<div> |
<label for="app_frontend_form_type_contact_form_type_contactType">Message subject</label> |
<div> |
<select name="app_frontend_form_type_contact_form_type[contactType]" id="app_frontend_form_type_contact_form_type_contactType"><option selected="selected" value="">Please select subject</option><option id="1">Test type</option></select> |
</div> |
</div> |
<div> |
<label for="app_frontend_form_type_contact_form_type_firstName">Firstname</label> |
<input type="text" name="app_frontend_form_type_contact_form_type[firstName]" value="John" id="app_frontend_form_type_contact_form_type_firstName"/> |
</div> |
</form> |
<button /> |
</html>'); |
|
return $dom; |
} |
|
protected function createTestMultipleForm() |
{ |
$dom = new \DOMDocument(); |
$dom->loadHTML(' |
<html> |
<h1>Hello form</h1> |
<form action="" method="POST"> |
<div><input type="checkbox" name="apples[]" value="1" checked /></div> |
<input type="checkbox" name="oranges[]" value="1" checked /> |
<div><label></label><input type="hidden" name="form_name" value="form-1" /></div> |
<input type="submit" name="button_1" value="Capture fields" /> |
<button type="submit" name="button_2">Submit form_2</button> |
</form> |
<form action="" method="POST"> |
<div><div><input type="checkbox" name="oranges[]" value="2" checked /> |
<input type="checkbox" name="oranges[]" value="3" checked /></div></div> |
<input type="hidden" name="form_name" value="form_2" /> |
<input type="hidden" name="outer_field" value="success" /> |
<button type="submit" name="button_3">Submit from outside the form</button> |
</form> |
<button /> |
</html>'); |
|
return $dom; |
} |
|
public function testgetPhpValuesWithEmptyTextarea() |
{ |
$dom = new \DOMDocument(); |
$dom->loadHTML(' |
<html> |
<form> |
<textarea name="example"></textarea> |
</form> |
</html> |
'); |
|
$nodes = $dom->getElementsByTagName('form'); |
$form = new Form($nodes->item(0), 'http://example.com'); |
$this->assertEquals($form->getPhpValues(), array('example' => '')); |
} |
} |