gistfile1.py

import pytest

import pypact

# 1. Start with your model

class Something(object):

    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.name == other.name


# 2. Create a skeleton client class

class MyServiceProviderClient(object):

    def __init__(self, base_uri):
        self.base_uri = base_uri

    def get_something(self):
        # Yet to be implemented because we're doing Test First Development...
        pass


# 3. Configure the mock server

@pytest.fixture(scope="session")
def my_consumer(request):
    consumer = pypact.Consumer("My Service Consumer")


@pytest.fixture(scope="session")
def my_service_provider(consumer):
    return pypact.Service("My Service Provider")


# 4. Write a failing spec for the client

@pytest.fixture
def subject(my_service_provider):
    subject = MyServiceProviderClient(my_service_provider.base_uri)
    return subject


@pytest.fixture
def mock_service(request, my_consumer, my_service_provider):
    return my_consumer.has_pact_with(my_service_provider)


def test_returns_something(subject, mock_service):
    """
    Subject returns a Something
    """
    (mock_service
        .given("something exists")
        .upon_receiving("a request for something")
        .with_request(method="get", path="/something")
        .will_respond_with(
            status=200,
            headers={'Content=Type': 'application/json'},
            body={'name': 'A small something'}))

    with mock_service:
        something = subject.get_something()

    assert something == Something(name='A small something')

I would do something along the lines of:

    def test_returns_something():
        with PyPact.Consumer("Animal Consumer").has_pact_with("Animal Server")
            .given("something exists")
            .upon_receiving("a request for something")
            .with_request(method="get", path="/something")
            .will_respond_with(
                status=200,
                headers={'Content=Type': 'application/json'},
                body={'name': 'A small something'})
            )() as mock_service:
             assert MyServiceProviderClient(mock_service.base_uri).get_something == Something(name='A small something')

but probably real python code that works :P

My assumption is that you want the thing that builds up the pact, to create a mock server that is closed when the with block completes. Ideally you don't want to do this as a local variable

    def test_returns_something():
        with (pypact.Consumer("Animal Consumer").has_pact_with("Animal Server")
            .given("something exists")
            .upon_receiving("a request for something")
            .with_request(method="get", path="/something")
            .will_respond_with(
                status=200,
                headers={'Content=Type': 'application/json'},
                body={'name': 'A small something'})
            ) as mock_service:
             assert MyServiceProviderClient(mock_service.base_uri).get_something == Something(name='A small something')

  (mock_service
        .given("a something exists")
        .upon_receiving("a request for something")
        .with_request(method="get", path="/something")
        .will_respond_with(
            status=200,
            headers={'Content=Type': 'application/json'},
            body={'rel': 'http://localhost:1234:/something/child'}))
        .given("something has a child")
        .upon_receiving("a request for something")
        .with_request(method="get", path="/something/child")
        .will_respond_with(
            status=200,
            headers={'Content=Type': 'application/json'},
            body={'name': 'A small something'}))

I also assume you're not running tests in parallel, otherwise the subject probably shouldn't be a fixture