Merge pull request #8 from pact-foundation/manage-mock-service

pact-python manages the mock service

Author: matthewbalvanz-wf

CHANGES.txt

@@ -1 +1,2 @@
 v0.1.0, 2017-03-30 -- Basic support for authoring contracts against a separately running mock service
+v0.2.0, 2017-04-22 -- Pact Python manages the Pact mock service

Makefile

@@ -39,9 +39,6 @@ e2e:
 	sh -c '\
 		cd e2e; \
 		docker-compose pull > /dev/null; \
-		docker-compose up -d pactmockservice; \
-		while ! nc -z localhost 1234; do sleep 0.1; done; \
-		docker-compose logs --follow > ./pacts/mock-service-logs.txt & \
 		nosetests ./contracts; \
 		docker-compose down; \
 		docker-compose up -d app pactverifier; \

README.md

@@ -40,14 +40,19 @@ def user(user_name):
 Then `Consumer`'s contract test might look something like this:
 
 ```python
+import atexit
 import unittest
 
 from pact import Consumer, Provider
 
 
+pact = Consumer('Consumer').has_pact_with(Provider('Provider'))
+pact.start_service()
+atexit.register(pact.stop_service)
+
+
 class GetUserInfoContract(unittest.TestCase):
   def test_get_user(self):
-    pact = Consumer('Consumer').has_pact_with(Provider('Provider'))
     expected = {
       'username': 'UserA',
       'id': 123,
@@ -77,7 +82,22 @@ This does a few important things:
 Using the Pact object as a [context manager], we call our method under test
 which will then communicate with the Pact mock service. The mock service will respond with
 the items we defined, allowing us to assert that the method processed the response and
-returned the expected value.
+returned the expected value. If you want more control over when the mock service is 
+configured and the interactions verified, use the `setup` and `verify` methods, respectively:
+
+```python
+   (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))
+
+    pact.setup()
+    # Some additional steps before running the code under test
+    result = user('UserA')
+    # Some additional steps before verifying all interactions have occurred
+    pact.verify()
+````
 
 The default hostname and port for the Pact mock service will be
 `localhost:1234` but you can adjust this during Pact creation:
@@ -88,13 +108,12 @@ pact = Consumer('Consumer').has_pact_with(
     Provider('Provider'), host_name='mockservice', port=8080)
 ```
 
-This can be useful if you are running your tests and the mock service inside a Docker
-network, where you want to reference the service by its Docker name, instead of via
-the `localhost` interface. It is important to note that the code you are testing with
-this contract _must_ contact the mock service. So in this example, the `user` method
-could accept an argument to specify the location of the server, or retrieve it from an
-environment variable so you can change its URI during the test. Another option is to
-specify a Docker network alias so the requests that you make will go to the container.
+This can be useful if you need to run to create more than one Pact for your test
+because your code interacts with two different services. It is important to note
+that the code you are testing with this contract _must_ contact the mock service.
+So in this example, the `user` method could accept an argument to specify the
+location of the server, or retrieve it from an environment variable so you can
+change its URI during the test.
 
 The mock service offers you several important features when building your contracts:
 - It provides a real HTTP server that your code can contact during the test and provides the responses you defined.

e2e/__init__.py

@@ -1,3 +1,5 @@
+import atexit
+
 import requests
 import unittest
 
@@ -6,29 +8,32 @@
 from pact.provider import Provider
 
 
+pact = Consumer('consumer').has_pact_with(Provider('provider'))
+pact.start_service()
+atexit.register(pact.stop_service)
+
+
 class BaseTestCase(unittest.TestCase):
-    def setUp(self):
-        self.pact = Consumer('consumer').has_pact_with(
-            Provider('provider'))
+    pass
 
 
 class ExactMatches(BaseTestCase):
     def test_get_user_sparse(self):
         expected = {'name': 'Jonas'}
-        (self.pact
+        (pact
             .given('a simple json blob exists')
             .upon_receiving('a request for a user')
             .with_request('get', '/users/Jonas')
             .will_respond_with(200, body=expected))
 
-        with self.pact:
+        with pact:
             result = requests.get('http://localhost:1234/users/Jonas')
 
         self.assertEqual(result.json(), expected)
 
     def test_post_user_complex(self):
         expected = {'name': 'Jonas'}
-        (self.pact
+        (pact
          .given('a simple json blob exists')
          .upon_receiving('a query for the user Jonas')
          .with_request(
@@ -42,7 +47,7 @@ def test_post_user_complex(self):
             body=expected,
             headers={'Content-Type': 'application/json'}))
 
-        with self.pact:
+        with pact:
             result = requests.post(
                 'http://localhost:1234/users/?Jonas',
                 headers={'Accept': 'application/json'},
@@ -53,21 +58,21 @@ def test_post_user_complex(self):
 
 class InexactMatches(BaseTestCase):
     def test_sparse(self):
-        (self.pact
+        (pact
          .given('the user `bob` exists')
          .upon_receiving('a request for the user object of `bob`')
          .with_request('get', '/users/bob')
          .will_respond_with(200, body={
              'username': SomethingLike('bob'),
              'id': Term('\d+', '123')}))
 
-        with self.pact:
+        with pact:
             result = requests.get('http://localhost:1234/users/bob')
 
         self.assertEqual(result.json(), {'username': 'bob', 'id': '123'})
 
     def test_nested(self):
-        (self.pact
+        (pact
          .given('a list of users exists')
          .upon_receiving('a query of all users')
          .with_request('get', '/users/', query={'limit': Term('\d+', '5')})
@@ -77,7 +82,7 @@ def test_nested(self):
             'groups': EachLike(123),
          }, minimum=2)}))
 
-        with self.pact:
+        with pact:
             results = requests.get(
                 'http://localhost:1234/users/?limit=4')
 
@@ -89,7 +94,7 @@ def test_nested(self):
 
 class SyntaxErrors(BaseTestCase):
     def test_incorrect_number_of_arguments(self):
-        (self.pact
+        (pact
          .given('a list of users exists')
          .upon_receiving('a request for a user')
          .with_request('get', '/users/')
@@ -99,7 +104,7 @@ def two(a, b):
             print('Requires two arguments')
 
         with self.assertRaises(TypeError) as e:
-            with self.pact:
+            with pact:
                 two('one')
 
         self.assertEqual(

e2e/contracts/test_e2e.py

@@ -6,4 +6,4 @@
 
 
 __all__ = ('Consumer', 'EachLike', 'Pact', 'Provider', 'SomethingLike', 'Term')
-__version__ = '0.1.0'
+__version__ = '0.2.0'

pact/__init__.py

@@ -0,0 +1,15 @@
+"""Constant values for the pact-python package."""
+import os
+from os.path import join, dirname, normpath
+
+
+def mock_service_exe():
+    """Get the appropriate executable name for this platform."""
+    if os.name == 'nt':
+        return 'pact-mock-service.bat'
+    else:
+        return 'pact-mock-service'
+
+
+MOCK_SERVICE_PATH = normpath(join(
+    dirname(__file__), 'bin', 'mock-service', 'bin', mock_service_exe()))

pact/constants.py

@@ -31,7 +31,9 @@ def __init__(self, name, service_cls=Pact):
         self.name = name
         self.service_cls = service_cls
 
-    def has_pact_with(self, provider, host_name='localhost', port=1234):
+    def has_pact_with(self, provider, host_name='localhost', port=1234,
+                      log_dir=None, ssl=False, sslcert=None, sslkey=None,
+                      cors=False, pact_dir=None, version='2.0.0'):
         """
         Create a contract between the `provider` and this consumer.
 
@@ -56,6 +58,28 @@ def has_pact_with(self, provider, host_name='localhost', port=1234):
             This will need to tbe the same port used by your code under test
             to contact the mock service. It defaults to: 1234
         :type port: int
+        :param log_dir: The directory where logs should be written. Defaults to
+            the current directory.
+        :type log_dir: str
+        :param ssl: Flag to control the use of a self-signed SSL cert to run
+            the server over HTTPS , defaults to False.
+        :type ssl: bool
+        :param sslcert: Path to a custom self-signed SSL cert file, 'ssl'
+            option must be set to True to use this option. Defaults to None.
+        :type sslcert: str
+        :param sslkey: Path to a custom key and self-signed SSL cert key file,
+            'ssl' option must be set to True to use this option.
+            Defaults to None.
+        :type sslkey: str
+        :param cors: Allow CORS OPTION requests to be accepted,
+            defaults to False.
+        :type cors: bool
+        :param pact_dir: Directory where the resulting pact files will be
+            written. Defaults to the current directory.
+        :type pact_dir: str
+        :param version: The Pact Specification version to use, defaults to
+            '2.0.0'.
+        :type version: str
         :return: A Pact object which you can use to define the specific
             interactions your code will have with the provider.
         :rtype: pact.Pact
@@ -68,4 +92,11 @@ def has_pact_with(self, provider, host_name='localhost', port=1234):
             consumer=self,
             provider=provider,
             host_name=host_name,
-            port=port)
+            port=port,
+            log_dir=log_dir,
+            ssl=ssl,
+            sslcert=sslcert,
+            sslkey=sslkey,
+            cors=cors,
+            pact_dir=pact_dir,
+            version=version)