Example #1
0
    def test_nested(self):
        (pact
         .given('a list of users exists')
         .upon_receiving('a query of all users')
         .with_request('get', '/users/', query={'limit': Term('\d+', '5')})
         .will_respond_with(200, body={'results': EachLike({
            'username': Term('\w+', 'bob'),
            'id': SomethingLike(123),
            'groups': EachLike(123),
            'meta': SomethingLike({
                'name': Term('.+', 'sample'),
                'value': Term('.+', 'data')
            })
         }, minimum=2)}))

        with pact:
            results = requests.get(
                'http://localhost:1234/users/?limit=4')

        self.assertEqual(results.json(), {
            'results': [
                {'username': '******', 'id': 123, 'groups': [123],
                 'meta': {'name': 'sample', 'value': 'data'}},
                {'username': '******', 'id': 123, 'groups': [123],
                 'meta': {'name': 'sample', 'value': 'data'}}]})
Example #2
0
    def test_sparse(self):
        (pact
         .given('the user `bob` exists')
         .upon_receiving('a request for the user object of `bob`')
         .with_request('get', Term('/users/[a-z]+', '/users/bob'))
         .will_respond_with(200, body={
             'username': SomethingLike('bob'),
             'id': Term('\d+', '123')}))

        with pact:
            result = requests.get('http://localhost:1234/users/bob')

        self.assertEqual(result.json(), {'username': '******', 'id': '123'})
def test_get_user_non_admin(pact, client):
    expected = {
        'name': 'UserA',
        'id': Term(r'[a-f0-9]+', '1234567'),
        'created_on': Term(r'\d+-\d+-\d+T\d+:\d+:\d+', '2016-12-15T20:16:01'),
        'admin': False
    }

    (pact.given('UserA exists and is not an administrator').upon_receiving(
        'a request for UserA').with_request(
            'get', '/users/UserA').will_respond_with(200, body=Like(expected)))

    with pact:
        result = client.get_user('UserA')
def test_get_user_non_admin(pact, consumer):
    # Define the Matcher; the expected structure and content of the response
    expected = {
        "name": "UserA",
        "id": Format().uuid,
        "created_on": Term(r"\d+-\d+-\d+T\d+:\d+:\d+", "2016-12-15T20:16:01"),
        "ip_address": Format().ip_address,
        "admin": False,
    }

    # Define the expected behaviour of the Provider. This determines how the
    # Pact mock provider will behave. In this case, we expect a body which is
    # "Like" the structure defined above. This means the mock provider will
    # return the EXACT content where defined, e.g. UserA for name, and SOME
    # appropriate content e.g. for ip_address.
    (pact.given("UserA exists and is not an administrator").upon_receiving(
        "a request for UserA").with_request(
            "get", "/users/UserA").will_respond_with(200, body=Like(expected)))

    with pact:
        # Perform the actual request
        user = consumer.get_user("UserA")

        # In this case the mock Provider will have returned a valid response
        assert user.name == "UserA"

        # Make sure that all interactions defined occurred
        pact.verify()
Example #5
0
def test_get_status(pact, client):
    #expected = {
    #    'name': 'UserA',
    #    'id': Term(
    #        r'^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}\Z',
    #        '00000000-0000-4000-a000-000000000000'
    #    ),
    #    'created_on': Term(
    #        r'\d+-\d+-\d+T\d+:\d+:\d+',
    #        '2016-12-15T20:16:01'
    #    ),
    #    'admin': False
    #}
    expected = {
        'buildTime': Term(
            r'\d+-\d+-\d+T\d+:\d+:\d+Z',
            '2018-09-10T11:08:26Z'
        ),
        'commit': Term(
            r'^[a-f0-9]+-dirty',
            '164762f67a3a7634fa4ee1e8bb55c458281803c7-dirty'
        ),
        'startTime': Term(
            r'\d+-\d+-\d+T\d+:\d+:\d+Z',
            '2018-09-10T11:08:26Z'
        )
    }

    (pact
     .given('status exists')
     .upon_receiving('a request for status')
     .with_request('get', '/status')
     .will_respond_with(200, body=Like(expected)))

    with pact:
        result = client.get_status('status')
def test_get_user_non_admin(pact, consumer):
    expected = {
        'name': 'UserA',
        'id': Format().uuid,
        'created_on': Term(r'\d+-\d+-\d+T\d+:\d+:\d+', '2016-12-15T20:16:01'),
        'ip_address': Format().ip_address,
        'admin': False
    }

    (pact.given('UserA exists and is not an administrator').upon_receiving(
        'a request for UserA').with_request(
            'get', '/users/UserA').will_respond_with(200, body=Like(expected)))

    with pact:
        user = consumer.get_user('UserA')
        assert user.name == 'UserA'
    def test_get_time(self):
        """Verify the expected response from the time server."""
        expected = {
            'currentTime':
            Term(
                '\d+-\d+-\d \d+:\d+:\d+',  # noqa W605
                '2016-12-15 20:16:01')
        }

        (pact.given('A request is made for the current time').upon_receiving(
            'a request for current time').with_request(
                'get', '/').will_respond_with(200, body=expected))

        with pact:
            result = get_time()

        self.assertEqual(result, expected)
Example #8
0
    def test_get_user(self):
        expected = {
            'username': '******',
            'id': 123,
            'groups': ['Editors'],
            'last_modified': Term(r'\d+-\d+-\d+T\d+:\d+:\d+', '2016-12-15T20:16:01'),
        }

        (pact
         .given('UserA exists and is not an administrator')
         .upon_receiving('a request for UserA')
         .with_request('get', '/users/UserA')
         .will_respond_with(200, body=expected))

        with pact:
            result = user('UserA')

        expected_result = expected.copy()
        expected_result['last_modified'] = expected_result['last_modified']._generate
        self.assertEqual(result, expected_result)
class ConsumerConfig(object):

    authenticate = {
        'path': '/api/v1/auth/authenticate/',
        'request_headers': {
            'Content-Type': 'application/json'
        },
        'request_payload': {
            "username": "******",
            "password": "******"
        },
        # this will validate the response has the UUID format (if the default value is not met)
        'response_body_matcher': {
            "token":
            Term('[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}',
                 'edff372c-55de-11e7-907b-a6006ad3dba0')
        }
    }

    def __init__(self):
        pass
Example #10
0
    def test_get_build(self):
        true = True
        ts = Term('\d+-\d+-\d+T\d+:\d+:\d+.+', u'2017-09-17T19:43:12+03:00')
        expected = {
            u'name': u'#3455',
            u'completed': true,  #boolean
            #  u'timestamp': Term('\d+-\d+-\d+T\d+:\d+:\d+.+', u'2017-09-17T19:43:12+03:00'),
            u'info': {
                u'coverage': 30,
                u'apiversion': 0.1,
                u'swaggerlink': u'http://swagger',
                u'buildtime': 230
            }
        }

        (pact.given('build 3455 exists').upon_receiving(
            'a request for build 3455').with_request(
                'get', '/builds/3455').will_respond_with(200, body=expected))

        with pact:
            result = client.build(3455)

        self.assertEqual(result, expected)