scrapy/tests/test_selector.py

import warnings
import weakref
from twisted.trial import unittest
from scrapy.http import TextResponse, HtmlResponse, XmlResponse
from scrapy.selector import Selector
from scrapy.selector.lxmlsel import XmlXPathSelector, HtmlXPathSelector, XPathSelector
from lxml import etree


class SelectorTestCase(unittest.TestCase):

    def test_simple_selection(self):
        """Simple selector tests"""
        body = b"<p><input name='a'value='1'/><input name='b'value='2'/></p>"
        response = TextResponse(url="http://example.com", body=body, encoding='utf-8')
        sel = Selector(response)

        xl = sel.xpath('//input')
        self.assertEqual(2, len(xl))
        for x in xl:
            assert isinstance(x, Selector)

        self.assertEqual(sel.xpath('//input').extract(),
                         [x.extract() for x in sel.xpath('//input')])

        self.assertEqual([x.extract() for x in sel.xpath("//input[@name='a']/@name")],
                         [u'a'])
        self.assertEqual([x.extract() for x in sel.xpath("number(concat(//input[@name='a']/@value, //input[@name='b']/@value))")],
                         [u'12.0'])

        self.assertEqual(sel.xpath("concat('xpath', 'rules')").extract(),
                         [u'xpathrules'])
        self.assertEqual([x.extract() for x in sel.xpath("concat(//input[@name='a']/@value, //input[@name='b']/@value)")],
                         [u'12'])

    def test_root_base_url(self):
        body = b'<html><form action="/path"><input name="a" /></form></html>'
        url = "http://example.com"
        response = TextResponse(url=url, body=body, encoding='utf-8')
        sel = Selector(response)
        self.assertEqual(url, sel.root.base)

    def test_deprecated_root_argument(self):
        with warnings.catch_warnings(record=True) as w:
            root = etree.fromstring(u'<html/>')
            sel = Selector(_root=root)
            self.assertIs(root, sel.root)
            self.assertEqual(str(w[-1].message),
                             'Argument `_root` is deprecated, use `root` instead')

    def test_deprecated_root_argument_ambiguous(self):
        with warnings.catch_warnings(record=True) as w:
            _root = etree.fromstring(u'<xml/>')
            root = etree.fromstring(u'<html/>')
            sel = Selector(_root=_root, root=root)
            self.assertIs(root, sel.root)
            self.assertIn('Ignoring deprecated `_root` argument', str(w[-1].message))

    def test_flavor_detection(self):
        text = b'<div><img src="a.jpg"><p>Hello</div>'
        sel = Selector(XmlResponse('http://example.com', body=text, encoding='utf-8'))
        self.assertEqual(sel.type, 'xml')
        self.assertEqual(sel.xpath("//div").extract(),
                         [u'<div><img src="a.jpg"><p>Hello</p></img></div>'])

        sel = Selector(HtmlResponse('http://example.com', body=text, encoding='utf-8'))
        self.assertEqual(sel.type, 'html')
        self.assertEqual(sel.xpath("//div").extract(),
                         [u'<div><img src="a.jpg"><p>Hello</p></div>'])

    def test_http_header_encoding_precedence(self):
        # u'\xa3'     = pound symbol in unicode
        # u'\xc2\xa3' = pound symbol in utf-8
        # u'\xa3'     = pound symbol in latin-1 (iso-8859-1)

        meta = u'<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">'
        head = u'<head>' + meta + u'</head>'
        body_content = u'<span id="blank">\xa3</span>'
        body = u'<body>' + body_content + u'</body>'
        html = u'<html>' + head + body + u'</html>'
        encoding = 'utf-8'
        html_utf8 = html.encode(encoding)

        headers = {'Content-Type': ['text/html; charset=utf-8']}
        response = HtmlResponse(url="http://example.com", headers=headers, body=html_utf8)
        x = Selector(response)
        self.assertEquals(x.xpath("//span[@id='blank']/text()").extract(),
                          [u'\xa3'])

    def test_badly_encoded_body(self):
        # \xe9 alone isn't valid utf8 sequence
        r1 = TextResponse('http://www.example.com', \
                          body=b'<html><p>an Jos\xe9 de</p><html>', \
                          encoding='utf-8')
        Selector(r1).xpath('//text()').extract()

    def test_weakref_slots(self):
        """Check that classes are using slots and are weak-referenceable"""
        x = Selector(text='')
        weakref.ref(x)
        assert not hasattr(x, '__dict__'), "%s does not use __slots__" % \
            x.__class__.__name__

    def test_deprecated_selector_methods(self):
        sel = Selector(TextResponse(url="http://example.com", body=b'<p>some text</p>'))

        with warnings.catch_warnings(record=True) as w:
            sel.select('//p')
            self.assertSubstring('Use .xpath() instead', str(w[-1].message))

        with warnings.catch_warnings(record=True) as w:
            sel.extract_unquoted()
            self.assertSubstring('Use .extract() instead', str(w[-1].message))

    def test_deprecated_selectorlist_methods(self):
        sel = Selector(TextResponse(url="http://example.com", body=b'<p>some text</p>'))

        with warnings.catch_warnings(record=True) as w:
            sel.xpath('//p').select('.')
            self.assertSubstring('Use .xpath() instead', str(w[-1].message))

        with warnings.catch_warnings(record=True) as w:
            sel.xpath('//p').extract_unquoted()
            self.assertSubstring('Use .extract() instead', str(w[-1].message))

    def test_selector_bad_args(self):
        with self.assertRaisesRegexp(ValueError, 'received both response and text'):
            Selector(TextResponse(url='http://example.com', body=b''), text=u'')


class DeprecatedXpathSelectorTest(unittest.TestCase):

    text = '<div><img src="a.jpg"><p>Hello</div>'

    def test_warnings_xpathselector(self):
        cls = XPathSelector
        with warnings.catch_warnings(record=True) as w:
            class UserClass(cls):
                pass

            # subclassing must issue a warning
            self.assertEqual(len(w), 1, str(cls))
            self.assertIn('scrapy.Selector', str(w[0].message))

            # subclass instance doesn't issue a warning
            usel = UserClass(text=self.text)
            self.assertEqual(len(w), 1)

            # class instance must issue a warning
            sel = cls(text=self.text)
            self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))
            self.assertIn('scrapy.Selector', str(w[1].message))

            # subclass and instance checks
            self.assertTrue(issubclass(cls, Selector))
            self.assertTrue(isinstance(sel, Selector))
            self.assertTrue(isinstance(usel, Selector))

    def test_warnings_xmlxpathselector(self):
        cls = XmlXPathSelector
        with warnings.catch_warnings(record=True) as w:
            class UserClass(cls):
                pass

            # subclassing must issue a warning
            self.assertEqual(len(w), 1, str(cls))
            self.assertIn('scrapy.Selector', str(w[0].message))

            # subclass instance doesn't issue a warning
            usel = UserClass(text=self.text)
            self.assertEqual(len(w), 1)

            # class instance must issue a warning
            sel = cls(text=self.text)
            self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))
            self.assertIn('scrapy.Selector', str(w[1].message))

            # subclass and instance checks
            self.assertTrue(issubclass(cls, Selector))
            self.assertTrue(issubclass(cls, XPathSelector))
            self.assertTrue(isinstance(sel, Selector))
            self.assertTrue(isinstance(usel, Selector))
            self.assertTrue(isinstance(sel, XPathSelector))
            self.assertTrue(isinstance(usel, XPathSelector))

    def test_warnings_htmlxpathselector(self):
        cls = HtmlXPathSelector
        with warnings.catch_warnings(record=True) as w:
            class UserClass(cls):
                pass

            # subclassing must issue a warning
            self.assertEqual(len(w), 1, str(cls))
            self.assertIn('scrapy.Selector', str(w[0].message))

            # subclass instance doesn't issue a warning
            usel = UserClass(text=self.text)
            self.assertEqual(len(w), 1)

            # class instance must issue a warning
            sel = cls(text=self.text)
            self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))
            self.assertIn('scrapy.Selector', str(w[1].message))

            # subclass and instance checks
            self.assertTrue(issubclass(cls, Selector))
            self.assertTrue(issubclass(cls, XPathSelector))
            self.assertTrue(isinstance(sel, Selector))
            self.assertTrue(isinstance(usel, Selector))
            self.assertTrue(isinstance(sel, XPathSelector))
            self.assertTrue(isinstance(usel, XPathSelector))
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`import warnings`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`import weakref`
			`from twisted.trial import unittest`
			`from scrapy.http import TextResponse, HtmlResponse, XmlResponse`
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`from scrapy.selector import Selector`
			`from scrapy.selector.lxmlsel import XmlXPathSelector, HtmlXPathSelector, XPathSelector`
remove selector support for LxmlDocument DOM cache and add deprecation warning for _root argument 2015-08-04 16:28:02 -03:00			`from lxml import etree`
Drop libxml2 selectors backend 2013-10-10 19:02:55 -02:00
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`class SelectorTestCase(unittest.TestCase):`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`def test_simple_selection(self):`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`"""Simple selector tests"""`
using bytes for response body in tests 2015-08-11 13:58:53 -03:00			`body = b"<p><input name='a'value='1'/><input name='b'value='2'/></p>"`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`response = TextResponse(url="http://example.com", body=body, encoding='utf-8')`
			`sel = Selector(response)`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`xl = sel.xpath('//input')`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`self.assertEqual(2, len(xl))`
			`for x in xl:`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`assert isinstance(x, Selector)`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual(sel.xpath('//input').extract(),`
			`[x.extract() for x in sel.xpath('//input')])`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual([x.extract() for x in sel.xpath("//input[@name='a']/@name")],`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'a'])`
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual([x.extract() for x in sel.xpath("number(concat(//input[@name='a']/@value, //input[@name='b']/@value))")],`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'12.0'])`

use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual(sel.xpath("concat('xpath', 'rules')").extract(),`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'xpathrules'])`
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual([x.extract() for x in sel.xpath("concat(//input[@name='a']/@value, //input[@name='b']/@value)")],`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'12'])`

set base_url in kwargs to be fully backward compatible 2015-08-11 14:06:24 -03:00			`def test_root_base_url(self):`
			`body = b'<html><form action="/path"><input name="a" /></form></html>'`
			`url = "http://example.com"`
			`response = TextResponse(url=url, body=body, encoding='utf-8')`
			`sel = Selector(response)`
			`self.assertEqual(url, sel.root.base)`

warning when ambiguous root arguments and minor cleanups 2015-08-09 01:21:39 -03:00			`def test_deprecated_root_argument(self):`
			`with warnings.catch_warnings(record=True) as w:`
			`root = etree.fromstring(u'<html/>')`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`sel = Selector(_root=root)`
warning when ambiguous root arguments and minor cleanups 2015-08-09 01:21:39 -03:00			`self.assertIs(root, sel.root)`
			`self.assertEqual(str(w[-1].message),`
			'Argument `_root` is deprecated, use `root` instead')

			`def test_deprecated_root_argument_ambiguous(self):`
			`with warnings.catch_warnings(record=True) as w:`
			`_root = etree.fromstring(u'<xml/>')`
			`root = etree.fromstring(u'<html/>')`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`sel = Selector(_root=_root, root=root)`
warning when ambiguous root arguments and minor cleanups 2015-08-09 01:21:39 -03:00			`self.assertIs(root, sel.root)`
			self.assertIn('Ignoring deprecated `_root` argument', str(w[-1].message))
remove selector support for LxmlDocument DOM cache and add deprecation warning for _root argument 2015-08-04 16:28:02 -03:00
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`def test_flavor_detection(self):`
using bytes for response body in tests 2015-08-11 13:58:53 -03:00			`text = b'<div><img src="a.jpg"><p>Hello</div>'`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`sel = Selector(XmlResponse('http://example.com', body=text, encoding='utf-8'))`
Replace `contenttype` references by `type` The type to choose from is the selector type, not the input type. A content-type doesn't make sense in this context. 2013-10-16 17:37:22 -02:00			`self.assertEqual(sel.type, 'xml')`
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual(sel.xpath("//div").extract(),`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'<div><img src="a.jpg"><p>Hello</p></img></div>'])`

cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`sel = Selector(HtmlResponse('http://example.com', body=text, encoding='utf-8'))`
Replace `contenttype` references by `type` The type to choose from is the selector type, not the input type. A content-type doesn't make sense in this context. 2013-10-16 17:37:22 -02:00			`self.assertEqual(sel.type, 'html')`
use `sel` name for Selector's instances in docs, internals and shell 2013-10-15 15:58:36 -02:00			`self.assertEqual(sel.xpath("//div").extract(),`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'<div><img src="a.jpg"><p>Hello</p></div>'])`

			`def test_http_header_encoding_precedence(self):`
			`# u'\xa3' = pound symbol in unicode`
			`# u'\xc2\xa3' = pound symbol in utf-8`
			`# u'\xa3' = pound symbol in latin-1 (iso-8859-1)`

			`meta = u'<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">'`
			`head = u'<head>' + meta + u'</head>'`
			`body_content = u'<span id="blank">\xa3</span>'`
			`body = u'<body>' + body_content + u'</body>'`
			`html = u'<html>' + head + body + u'</html>'`
			`encoding = 'utf-8'`
			`html_utf8 = html.encode(encoding)`

			`headers = {'Content-Type': ['text/html; charset=utf-8']}`
			`response = HtmlResponse(url="http://example.com", headers=headers, body=html_utf8)`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`x = Selector(response)`
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`self.assertEquals(x.xpath("//span[@id='blank']/text()").extract(),`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00			`[u'\xa3'])`

more fixes to lxml selector incompatibilities * Do not fail parsing empty bodies * Do not fail parsing bodies with null bytes * Recode to utf8 using response.body_as_unicode() to avoid decoding bugs * Return empty results with unevaluable nodes like text or attribute nodes * Return u'1' and u'0' for boolean xpaths 2012-04-13 00:21:48 -03:00			`def test_badly_encoded_body(self):`
			`# \xe9 alone isn't valid utf8 sequence`
			`r1 = TextResponse('http://www.example.com', \`
using bytes for response body in tests 2015-08-11 13:58:53 -03:00			`body=b'<html><p>an Jos\xe9 de</p><html>', \`
more fixes to lxml selector incompatibilities * Do not fail parsing empty bodies * Do not fail parsing bodies with null bytes * Recode to utf8 using response.body_as_unicode() to avoid decoding bugs * Return empty results with unevaluable nodes like text or attribute nodes * Return u'1' and u'0' for boolean xpaths 2012-04-13 00:21:48 -03:00			`encoding='utf-8')`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`Selector(r1).xpath('//text()').extract()`
refactored selectors tests, by splitting tests in: common tests, lxml-specific tests and libxml2-specific tests. refs #147 2010-10-27 08:37:02 -02:00
			`def test_weakref_slots(self):`
			`"""Check that classes are using slots and are weak-referenceable"""`
cleanup tests for selectors and translators 2015-08-09 15:23:43 -03:00			`x = Selector(text='')`
port tests to new Selector class 2013-10-14 10:35:02 -02:00			`weakref.ref(x)`
			`assert not hasattr(x, '__dict__'), "%s does not use __slots__" % \`
			`x.__class__.__name__`

upgrade parsel and add shim for deprecated selectorlist methods 2015-08-11 15:20:33 -03:00			`def test_deprecated_selector_methods(self):`
			`sel = Selector(TextResponse(url="http://example.com", body=b'<p>some text</p>'))`

			`with warnings.catch_warnings(record=True) as w:`
			`sel.select('//p')`
			`self.assertSubstring('Use .xpath() instead', str(w[-1].message))`

			`with warnings.catch_warnings(record=True) as w:`
			`sel.extract_unquoted()`
			`self.assertSubstring('Use .extract() instead', str(w[-1].message))`

			`def test_deprecated_selectorlist_methods(self):`
			`sel = Selector(TextResponse(url="http://example.com", body=b'<p>some text</p>'))`

			`with warnings.catch_warnings(record=True) as w:`
			`sel.xpath('//p').select('.')`
			`self.assertSubstring('Use .xpath() instead', str(w[-1].message))`

			`with warnings.catch_warnings(record=True) as w:`
			`sel.xpath('//p').extract_unquoted()`
			`self.assertSubstring('Use .extract() instead', str(w[-1].message))`

Selector should not receive both response and text 2016-07-29 17:13:59 +03:00			`def test_selector_bad_args(self):`
			`with self.assertRaisesRegexp(ValueError, 'received both response and text'):`
			`Selector(TextResponse(url='http://example.com', body=b''), text=u'')`

port tests to new Selector class 2013-10-14 10:35:02 -02:00
			`class DeprecatedXpathSelectorTest(unittest.TestCase):`

using bytes for response body in tests 2015-08-11 13:58:53 -03:00			`text = '<div><img src="a.jpg"><p>Hello</div>'`
port tests to new Selector class 2013-10-14 10:35:02 -02:00
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00			`def test_warnings_xpathselector(self):`
			`cls = XPathSelector`
			`with warnings.catch_warnings(record=True) as w:`
			`class UserClass(cls):`
			`pass`

			`# subclassing must issue a warning`
			`self.assertEqual(len(w), 1, str(cls))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[0].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass instance doesn't issue a warning`
			`usel = UserClass(text=self.text)`
			`self.assertEqual(len(w), 1)`

			`# class instance must issue a warning`
			`sel = cls(text=self.text)`
			`self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[1].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass and instance checks`
			`self.assertTrue(issubclass(cls, Selector))`
			`self.assertTrue(isinstance(sel, Selector))`
			`self.assertTrue(isinstance(usel, Selector))`

			`def test_warnings_xmlxpathselector(self):`
			`cls = XmlXPathSelector`
			`with warnings.catch_warnings(record=True) as w:`
			`class UserClass(cls):`
			`pass`

			`# subclassing must issue a warning`
			`self.assertEqual(len(w), 1, str(cls))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[0].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass instance doesn't issue a warning`
			`usel = UserClass(text=self.text)`
			`self.assertEqual(len(w), 1)`

			`# class instance must issue a warning`
			`sel = cls(text=self.text)`
			`self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[1].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass and instance checks`
			`self.assertTrue(issubclass(cls, Selector))`
			`self.assertTrue(issubclass(cls, XPathSelector))`
			`self.assertTrue(isinstance(sel, Selector))`
			`self.assertTrue(isinstance(usel, Selector))`
			`self.assertTrue(isinstance(sel, XPathSelector))`
			`self.assertTrue(isinstance(usel, XPathSelector))`

			`def test_warnings_htmlxpathselector(self):`
			`cls = HtmlXPathSelector`
			`with warnings.catch_warnings(record=True) as w:`
			`class UserClass(cls):`
			`pass`

			`# subclassing must issue a warning`
			`self.assertEqual(len(w), 1, str(cls))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[0].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass instance doesn't issue a warning`
			`usel = UserClass(text=self.text)`
			`self.assertEqual(len(w), 1)`

			`# class instance must issue a warning`
			`sel = cls(text=self.text)`
			`self.assertEqual(len(w), 2, str((cls, [x.message for x in w])))`
suggest scrapy.Selector in deprecation warnings 2014-04-10 03:32:00 +06:00			`self.assertIn('scrapy.Selector', str(w[1].message))`
warn XPathSelector deprecation on subclassing and direct instance 2014-01-03 17:32:40 -02:00
			`# subclass and instance checks`
			`self.assertTrue(issubclass(cls, Selector))`
			`self.assertTrue(issubclass(cls, XPathSelector))`
			`self.assertTrue(isinstance(sel, Selector))`
			`self.assertTrue(isinstance(usel, Selector))`
			`self.assertTrue(isinstance(sel, XPathSelector))`
using bytes for response body in tests 2015-08-11 13:58:53 -03:00			`self.assertTrue(isinstance(usel, XPathSelector))`