httpretty_fixtures 2.1.1

Getting Started

Install the module with: pip install httpretty_fixtures

# Load in our dependencies
import json
import unittest

import httpretty_fixtures
import requests


# Set up our fixture manager
class FakeElasticsearch(httpretty_fixtures.FixtureManager):
    @httpretty_fixtures.get('http://localhost:9200/my_index/my_document/my_id')
    def es_index(self, request, uri, res_headers):
        return (200, res_headers, json.dumps({
            '_index': 'my_index',
            '_type': 'my_document',
            '_id': 'my_id',
            '_version': 1,
            'found': True,
        }))


# Define our tests
class MyTestCase(unittest.TestCase):
    @FakeElasticsearch.run(['es_index'])
    def test_retrieve_from_es(self, fake_elasticsearch):
        """Verify we can retrieve an item from Elasticsearch"""
        # Make our request and verify we hit Elasticsearch
        res = requests.get('http://localhost:9200/my_index/my_document/my_id?first')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.json()['_index'], 'my_index')

        # Make a second request for demonstration purposes
        requests.get('http://localhost:9200/my_index/my_document/my_id?second')

        # Introspect our request received on `FakeElasticsearch`
        fixture = fake_elasticsearch.es_index
        self.assertEqual(fixture.first_request.path, '/my_index/my_document/my_id?first')
        self.assertEqual(fixture.last_request.path, '/my_index/my_document/my_id?second')
        self.assertEqual(len(fixture.requests), 2)
        self.assertEqual(fixture.requests[0].path, '/my_index/my_document/my_id?first')
        self.assertEqual(fixture.requests[1].path, '/my_index/my_document/my_id?second')

        # Access request information from all `httpretty` requests
        self.assertEqual(httpretty_fixtures.first_request().path, '/my_index/my_document/my_id?first')
        self.assertEqual(httpretty_fixtures.last_request().path, '/my_index/my_document/my_id?second')
        self.assertEqual(len(httpretty_fixtures.requests()), 2)
        self.assertEqual(httpretty_fixtures.requests()[0].path, '/my_index/my_document/my_id?first')
        self.assertEqual(httpretty_fixtures.requests()[1].path, '/my_index/my_document/my_id?second')

Documentation

httpretty-fixtures exports FixtureManager, get, put, post, delete, head, patch, options, connect, first_request, last_request, and requests as methods/variables.

We will refer to the package as httpretty_fixtures.

class FakeElasticsearch(httpretty_fixtures.FixtureManager):
    @httpretty_fixtures.get('http://localhost:9200/my_index/my_document/my_id')
    def es_index(self, request, uri, res_headers):
        return (200, res_headers, json.dumps({'content': 'goes here'}))

class FakeElasticsearch(httpretty_fixtures.FixtureManager):
    @httpretty_fixtures.get('http://localhost:9200/my_index/my_document/my_id')
    def es_index(self, request, uri, res_headers):
        return (200, res_headers, json.dumps({}))

class MyTestCase(unittest.TestCase):
    # The `es_index` fixture will be live for all of this test case
    @FakeElasticsearch.run(['es_index'])
    def test_retrieve_from_es(self, fake_elasticsearch):
        """Verify we can retrieve an item from Elasticsearch"""
        # Make our request and verify we hit Elasticsearch
        res = requests.get('http://localhost:9200/my_index/my_document/my_id')

@httpretty_fixtures.get()
@httpretty_fixtures.put()
@httpretty_fixtures.post()
@httpretty_fixtures.delete()
@httpretty_fixtures.head()
@httpretty_fixtures.patch()
@httpretty_fixtures.options()
@httpretty_fixtures.connect()

@httpretty_fixtures.get("http://underdog.io/")

@httpretty_fixtures.get("http://underdog.io/")
def request_handler(self, request, uri, res_headers):
    res_tuple = (status_code, res_headers, body)
    return res_tuple

# Example
@httpretty_fixtures.get("http://underdog.io/")
def hello(self, request, uri, res_headers):
    return (200, res_headers, 'Hello World!')

class MyTestCase(unittest.TestCase):
    # The `es_index` fixture will be live for all of this test case
    @FakeElasticsearch.run(['es_index'])
    def test_retrieve_from_es(self, fake_elasticsearch):
        # Access our `fixture` and its properties
        fake_elasticsearch.es_index
        fake_elasticsearch.es_index.first_request
        fake_elasticsearch.es_index.last_request
        fake_elasticsearch.es_index.requests

Examples

Preserving state between requests

In this example, we will count between multiple requests to indicate that state is being preserved.

# Load in our dependencies
import unittest

import httpretty_fixtures
import requests


# Set up our fixture manager
class CounterServer(httpretty_fixtures.FixtureManager):
    def __init__(self):
        self.count = 0
        super(CounterServer, self).__init__()

    @httpretty_fixtures.get('http://localhost:9000/')
    def counter(self, request, uri, res_headers):
        self.count += 1
        return (200, res_headers, str(self.count))


# Define our tests
class MyTestCase(unittest.TestCase):
    @CounterServer.run(['counter'])
    def test_counter_state(self, counter_server):
        """Verify we can preserve state between requests"""
        # Make our first request and verify its count
        res = requests.get('http://localhost:9000/')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.text, '1')

        # Make our second request and verify its count
        res = requests.get('http://localhost:9000/')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.text, '2')

    @CounterServer.run(['counter'])
    def test_counter_alternate_state(self, counter_server):
        """Verify state is not maintained between separate `FixtureManager.run()'s`"""
        res = requests.get('http://localhost:9000/')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.text, '1')

Contributing

In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Test via nosetests.

License

Copyright (c) 2015 Underdog.io

Licensed under the MIT license.