Испытания блока Scrapy

Я сделал это так, чтобы создать фальшивые ответы, чтобы вы могли протестировать функцию синтаксического анализа в автономном режиме. Но реальную ситуацию можно получить, используя настоящий HTML.

Проблема с этим подходом заключается в том, что ваш локальный HTML-файл может не отражать последнее состояние в сети. Так что, если HTML изменяется онлайн, у вас может быть большая ошибка, но ваши тестовые примеры все равно пройдут. Так что это может быть не лучший способ проверить этот способ.

Мой текущий рабочий процесс: всякий раз, когда возникает ошибка, я отправляю электронное письмо администратору с URL-адресом. Затем для этой конкретной ошибки я создаю html-файл с содержимым, которое вызывает ошибку. Затем я создаю для него unittest.

Это код, который я использую для создания примеров HTTP-ответов Scrapy для тестирования из локального файла HTML:

# scrapyproject/tests/responses/__init__.py

import os

from scrapy.http import Response, Request

def fake_response_from_file(file_name, url=None):
    """
    Create a Scrapy fake HTTP response from a HTML file
    @param file_name: The relative filename from the responses directory,
                      but absolute paths are also accepted.
    @param url: The URL of the response.
    returns: A scrapy HTTP response which can be used for unittesting.
    """
    if not url:
        url = 'http://www.example.com'

    request = Request(url=url)
    if not file_name[0] == '/':
        responses_dir = os.path.dirname(os.path.realpath(__file__))
        file_path = os.path.join(responses_dir, file_name)
    else:
        file_path = file_name

    file_content = open(file_path, 'r').read()

    response = Response(url=url,
        request=request,
        body=file_content)
    response.encoding = 'utf-8'
    return response

Образец html-файла находится в scrapyproject / tests / answers / osdir / sample.html.

Тогда тестовый пример может выглядеть следующим образом: Местоположение тестового примера - scrapyproject / tests / test_osdir.py

import unittest
from scrapyproject.spiders import osdir_spider
from responses import fake_response_from_file

class OsdirSpiderTest(unittest.TestCase):

    def setUp(self):
        self.spider = osdir_spider.DirectorySpider()

    def _test_item_results(self, results, expected_length):
        count = 0
        permalinks = set()
        for item in results:
            self.assertIsNotNone(item['content'])
            self.assertIsNotNone(item['title'])
        self.assertEqual(count, expected_length)

    def test_parse(self):
        results = self.spider.parse(fake_response_from_file('osdir/sample.html'))
        self._test_item_results(results, 10)

В основном так я тестирую свои методы синтаксического анализа, но не только для методов синтаксического анализа. Если это станет более сложным, я предлагаю взглянуть на Mox.

Я использую Betamax, чтобы запустить тест на реальном сайте в первый раз и сохранить http ответы локально, чтобы следующие тесты выполнялись очень быстро после:

Betamax перехватывает каждый ваш запрос и пытается найти соответствующий запрос, который уже был перехвачен и записан.

Когда вам нужно получить последнюю версию сайта, просто удалите то, что записано Betamax, и повторно запустите тест.

Пример:

from scrapy import Spider, Request
from scrapy.http import HtmlResponse


class Example(Spider):
    name = 'example'

    url = 'http://doc.scrapy.org/en/latest/_static/selectors-sample1.html'

    def start_requests(self):
        yield Request(self.url, self.parse)

    def parse(self, response):
        for href in response.xpath('//a/@href').extract():
            yield {'image_href': href}


# Test part
from betamax import Betamax
from betamax.fixtures.unittest import BetamaxTestCase


with Betamax.configure() as config:
    # where betamax will store cassettes (http responses):
    config.cassette_library_dir = 'cassettes'
    config.preserve_exact_body_bytes = True


class TestExample(BetamaxTestCase):  # superclass provides self.session

    def test_parse(self):
        example = Example()

        # http response is recorded in a betamax cassette:
        response = self.session.get(example.url)

        # forge a scrapy response to test
        scrapy_response = HtmlResponse(body=response.content, url=example.url)

        result = example.parse(scrapy_response)

        self.assertEqual({'image_href': u'image1.html'}, result.next())
        self.assertEqual({'image_href': u'image2.html'}, result.next())
        self.assertEqual({'image_href': u'image3.html'}, result.next())
        self.assertEqual({'image_href': u'image4.html'}, result.next())
        self.assertEqual({'image_href': u'image5.html'}, result.next())

        with self.assertRaises(StopIteration):
            result.next()

К вашему сведению, я обнаружил Betamax на pycon 2015 благодаря Выступление Яна Кордаско.

Стоит попробовать недавно добавленные контракты паука. Это дает вам простой способ добавлять тесты, не требуя большого количества кода.

Это очень поздний ответ, но меня раздражало тестирование scrapy, поэтому я написал scrapy-test фреймворк для тестирования сканеров scrapy на соответствие определенным спецификациям.

Он работает путем определения тестовых спецификаций, а не статического вывода. Например, если мы сканируем такие элементы:

{
    "name": "Alex",
    "age": 21,
    "gender": "Female",
}

Мы можем определить scrapy-test ItemSpec:

from scrapytest.tests import Match, MoreThan, LessThan
from scrapytest.spec import ItemSpec

class MySpec(ItemSpec):
    name_test = Match('{3,}')  # name should be at least 3 characters long
    age_test = Type(int), MoreThan(18), LessThan(99)
    gender_test = Match('Female|Male')

Также есть те же тесты идей для статистики scrapy, что и StatsSpec:

from scrapytest.spec import StatsSpec
from scrapytest.tests import Morethan

class MyStatsSpec(StatsSpec):
    validate = {
        "item_scraped_count": MoreThan(0),
    }

Впоследствии его можно запускать для живых или кешированных результатов:

$ scrapy-test 
# or
$ scrapy-test --cache

Я выполнял кэшированные прогоны для изменений в разработке и ежедневные cronjobs для обнаружения изменений на веб-сайтах.

Я использую Twisted trial для запуска тестов, похожих на собственные тесты Scrapy. Он уже запускает реактор, поэтому я использую CrawlerRunner, не беспокоясь о запуске и остановке реактора в тестах.

Позаимствовав некоторые идеи из команд check и parse Scrapy, я получил следующий базовый класс TestCase для выполнения утверждений на живых сайтах:

from twisted.trial import unittest

from scrapy.crawler import CrawlerRunner
from scrapy.http import Request
from scrapy.item import BaseItem
from scrapy.utils.spider import iterate_spider_output

class SpiderTestCase(unittest.TestCase):
    def setUp(self):
        self.runner = CrawlerRunner()

    def make_test_class(self, cls, url):
        """
        Make a class that proxies to the original class,
        sets up a URL to be called, and gathers the items
        and requests returned by the parse function.
        """
        class TestSpider(cls):
            # This is a once used class, so writing into
            # the class variables is fine. The framework
            # will instantiate it, not us.
            items = []
            requests = []

            def start_requests(self):
                req = super(TestSpider, self).make_requests_from_url(url)
                req.meta["_callback"] = req.callback or self.parse
                req.callback = self.collect_output
                yield req

            def collect_output(self, response):
                try:
                    cb = response.request.meta["_callback"]
                    for x in iterate_spider_output(cb(response)):
                        if isinstance(x, (BaseItem, dict)):
                            self.items.append(x)
                        elif isinstance(x, Request):
                            self.requests.append(x)
                except Exception as ex:
                    print("ERROR", "Could not execute callback: ",     ex)
                    raise ex

                # Returning any requests here would make the     crawler follow them.
                return None

        return TestSpider

Пример:

@defer.inlineCallbacks
def test_foo(self):
    tester = self.make_test_class(FooSpider, 'https://foo.com')
    yield self.runner.crawl(tester)
    self.assertEqual(len(tester.items), 1)
    self.assertEqual(len(tester.requests), 2)

или выполните один запрос в настройке и запустите несколько тестов по результатам:

@defer.inlineCallbacks
def setUp(self):
    super(FooTestCase, self).setUp()
    if FooTestCase.tester is None:
        FooTestCase.tester = self.make_test_class(FooSpider, 'https://foo.com')
        yield self.runner.crawl(self.tester)

def test_foo(self):
    self.assertEqual(len(self.tester.items), 1)

Чуть проще, убрав def fake_response_from_file из выбранного ответа:

import unittest
from spiders.my_spider import MySpider
from scrapy.selector import Selector


class TestParsers(unittest.TestCase):


    def setUp(self):
        self.spider = MySpider(limit=1)
        self.html = Selector(text=open("some.htm", 'r').read())


    def test_some_parse(self):
        expected = "some-text"
        result = self.spider.some_parse(self.html)
        self.assertEqual(result, expected)


if __name__ == '__main__':
    unittest.main()

Я использую scrapy 1.3.0 и функцию: fake_response_from_file, вызывает ошибку:

response = Response(url=url, request=request, body=file_content)

Я получил:

raise AttributeError("Response content isn't text")

Решение состоит в том, чтобы использовать вместо этого TextResponse, и он работает нормально, например:

response = TextResponse(url=url, request=request, body=file_content)     

Большое спасибо.

Вы можете выполнить этот фрагмент с сайта scrapy, чтобы запустить его из сценария. Затем вы можете делать любые утверждения по возвращенным товарам.

https://github.com/ThomasAitken/Scrapy-Testmaster

Это пакет, который я написал, который значительно расширяет функциональность библиотеки Scrapy Autounit и развивает ее в другом направлении (позволяя легко динамически обновлять тестовые наборы и объединять процессы отладки / генерации тестов). Он также включает измененную версию команды Scrapy parse (https://docs.scrapy.org/en/latest/topics/commands.html#std-command-parse)

Подобно ответу Хадриена, но для pytest: pytest-vcr.

import requests
import pytest
from scrapy.http import HtmlResponse

@pytest.mark.vcr()
def test_parse(url, target):
    response = requests.get(url)
    scrapy_response = HtmlResponse(url, body=response.content)
    assert Spider().parse(scrapy_response) == target