Merge pull request #41 from pact-foundation/fix-running-on-windows

Move to using the `service` command with pact-mock-service

Author: matthewbalvanz-wf

pact/pact.py

@@ -2,9 +2,13 @@
 from __future__ import unicode_literals
 
 import os
+import platform
 from subprocess import Popen
 
+import psutil
 import requests
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3 import Retry
 
 from .constants import MOCK_SERVICE_PATH
 from .matchers import from_term
@@ -87,6 +91,7 @@ def __init__(self, consumer, provider, host_name='localhost', port=1234,
         self.sslkey = sslkey
         self.version = version
         self._interactions = []
+        self._process = None
 
     def given(self, provider_state):
         """
@@ -120,10 +125,14 @@ def setup(self):
             raise
 
     def start_service(self):
-        """Start the external Mock Service."""
+        """
+        Start the external Mock Service.
+
+        :raises RuntimeError: if there is a problem starting the mock service.
+        """
         command = [
             MOCK_SERVICE_PATH,
-            'start',
+            'service',
             '--host={}'.format(self.host_name),
             '--port={}'.format(self.port),
             '--log', '{}/pact-mock-service.log'.format(self.log_dir),
@@ -139,17 +148,22 @@ def start_service(self):
         if self.sslkey:
             command.extend(['--sslkey', self.sslkey])
 
-        process = Popen(command)
-        process.communicate()
-        if process.returncode != 0:
-            raise RuntimeError('The Pact mock service failed to start.')
+        self._process = Popen(command)
+        self._wait_for_server_start()
 
     def stop_service(self):
         """Stop the external Mock Service."""
-        command = [MOCK_SERVICE_PATH, 'stop', '--port={}'.format(self.port)]
-        popen = Popen(command)
-        popen.communicate()
-        if popen.returncode != 0:
+        is_windows = 'windows' in platform.platform().lower()
+        if is_windows:
+            # Send the signal to ruby.exe, not the *.bat process
+            p = psutil.Process(self._process.pid)
+            for child in p.children(recursive=True):
+                child.terminate()
+        else:
+            self._process.terminate()
+
+        self._process.communicate()
+        if self._process.returncode != 0:
             raise RuntimeError(
                 'There was an error when stopping the Pact mock service.')
 
@@ -229,6 +243,23 @@ def will_respond_with(self, status, headers=None, body=None):
                                                      body=body).json()
         return self
 
+    def _wait_for_server_start(self):
+        """
+        Wait for the mock service to be ready for requests.
+
+        :rtype: None
+        :raises RuntimeError: If there is a problem starting the mock service.
+        """
+        s = requests.Session()
+        retries = Retry(total=15, backoff_factor=0.1)
+        s.mount('http://', HTTPAdapter(max_retries=retries))
+        resp = s.get(self.uri, headers=self.HEADERS)
+        if resp.status_code != 200:
+            self._process.terminate()
+            self._process.communicate()
+            raise RuntimeError(
+                'There was a problem starting the mock service: %s', resp.text)
+
     def __enter__(self):
         """
         Handler for entering a Python context.

pact/test/test_pact.py

@@ -1,7 +1,9 @@
 import os
+from subprocess import Popen
 from unittest import TestCase
 
 from mock import patch, call, Mock
+from psutil import Process
 
 from .. import Consumer, Provider, pact
 from ..constants import MOCK_SERVICE_PATH
@@ -208,17 +210,24 @@ def setUp(self):
         self.addCleanup(patch.stopall)
         self.mock_Popen = patch.object(pact, 'Popen', autospec=True).start()
         self.mock_Popen.return_value.returncode = 0
+        self.mock_Process = patch.object(
+            pact.psutil, 'Process', autospec=True).start()
+        self.mock_platform = patch.object(
+            pact.platform, 'platform', autospec=True).start()
+        self.mock_wait_for_server_start = patch.object(
+            pact.Pact, '_wait_for_server_start', autospec=True).start()
 
     def test_start_fails(self):
         self.mock_Popen.return_value.returncode = 1
+        self.mock_wait_for_server_start.side_effect = RuntimeError
         pact = Pact(Consumer('consumer'), Provider('provider'),
                     log_dir='/logs', pact_dir='/pacts')
 
         with self.assertRaises(RuntimeError):
             pact.start_service()
 
         self.mock_Popen.assert_called_once_with([
-            MOCK_SERVICE_PATH, 'start',
+            MOCK_SERVICE_PATH, 'service',
             '--host=localhost',
             '--port=1234',
             '--log', '/logs/pact-mock-service.log',
@@ -227,15 +236,13 @@ def test_start_fails(self):
             '--consumer', 'consumer',
             '--provider', 'provider'])
 
-        self.mock_Popen.return_value.communicate.assert_called_once_with()
-
     def test_start_no_ssl(self):
         pact = Pact(Consumer('consumer'), Provider('provider'),
                     log_dir='/logs', pact_dir='/pacts')
         pact.start_service()
 
         self.mock_Popen.assert_called_once_with([
-            MOCK_SERVICE_PATH, 'start',
+            MOCK_SERVICE_PATH, 'service',
             '--host=localhost',
             '--port=1234',
             '--log', '/logs/pact-mock-service.log',
@@ -244,16 +251,14 @@ def test_start_no_ssl(self):
             '--consumer', 'consumer',
             '--provider', 'provider'])
 
-        self.mock_Popen.return_value.communicate.assert_called_once_with()
-
     def test_start_with_ssl(self):
         pact = Pact(Consumer('consumer'), Provider('provider'),
                     log_dir='/logs', pact_dir='/pacts',
                     ssl=True, sslcert='/ssl.cert', sslkey='/ssl.key')
         pact.start_service()
 
         self.mock_Popen.assert_called_once_with([
-            MOCK_SERVICE_PATH, 'start',
+            MOCK_SERVICE_PATH, 'service',
             '--host=localhost',
             '--port=1234',
             '--log', '/logs/pact-mock-service.log',
@@ -265,25 +270,86 @@ def test_start_with_ssl(self):
             '--sslcert', '/ssl.cert',
             '--sslkey', '/ssl.key'])
 
-        self.mock_Popen.return_value.communicate.assert_called_once_with()
+    def test_stop_posix(self):
+        self.mock_platform.return_value = 'Linux'
+        pact = Pact(Consumer('consumer'), Provider('provider'))
+        pact._process = Mock(spec=Popen, pid=999, returncode=0)
+        pact.stop_service()
+
+        pact._process.terminate.assert_called_once_with()
+        pact._process.communicate.assert_called_once_with()
+        self.assertFalse(self.mock_Process.called)
 
-    def test_stop(self):
+    def test_stop_windows(self):
+        self.mock_platform.return_value = 'Windows'
+        ruby_exe = Mock(spec=Process)
+        self.mock_Process.return_value.children.return_value = [ruby_exe]
         pact = Pact(Consumer('consumer'), Provider('provider'))
+        pact._process = Mock(spec=Popen, pid=999, returncode=0)
         pact.stop_service()
 
-        self.mock_Popen.assert_called_once_with(
-            [MOCK_SERVICE_PATH, 'stop', '--port=1234'])
-        self.mock_Popen.return_value.communicate.assert_called_once_with()
+        self.assertFalse(pact._process.terminate.called)
+        pact._process.communicate.assert_called_once_with()
+        self.mock_Process.assert_called_once_with(999)
+        self.mock_Process.return_value.children.assert_called_once_with(
+            recursive=True)
+        ruby_exe.terminate.assert_called_once_with()
 
     def test_stop_fails(self):
         self.mock_Popen.return_value.returncode = 1
         pact = Pact(Consumer('consumer'), Provider('provider'))
+        pact._process = Mock(spec=Popen, pid=999, returncode=1)
         with self.assertRaises(RuntimeError):
             pact.stop_service()
 
-        self.mock_Popen.assert_called_once_with(
-            [MOCK_SERVICE_PATH, 'stop', '--port=1234'])
-        self.mock_Popen.return_value.communicate.assert_called_once_with()
+        pact._process.terminate.assert_called_once_with()
+        pact._process.communicate.assert_called_once_with()
+
+
+class PactWaitForServerStartTestCase(TestCase):
+    def setUp(self):
+        super(PactWaitForServerStartTestCase, self).setUp()
+        self.addCleanup(patch.stopall)
+        self.mock_HTTPAdapter = patch.object(
+            pact, 'HTTPAdapter', autospec=True).start()
+        self.mock_Retry = patch.object(pact, 'Retry', autospec=True).start()
+        self.mock_Session = patch.object(
+            pact.requests, 'Session', autospec=True).start()
+
+    def test_wait_for_server_start_success(self):
+        self.mock_Session.return_value.get.return_value.status_code = 200
+        pact = Pact(Consumer('consumer'), Provider('provider'))
+        pact._process = Mock(spec=Popen)
+        pact._wait_for_server_start()
+
+        session = self.mock_Session.return_value
+        session.mount.assert_called_once_with(
+            'http://', self.mock_HTTPAdapter.return_value)
+        session.get.assert_called_once_with(
+            'http://localhost:1234', headers={'X-Pact-Mock-Service': 'true'})
+        self.mock_HTTPAdapter.assert_called_once_with(
+            max_retries=self.mock_Retry.return_value)
+        self.mock_Retry.assert_called_once_with(total=15, backoff_factor=0.1)
+        self.assertFalse(pact._process.communicate.called)
+        self.assertFalse(pact._process.terminate.called)
+
+    def test_wait_for_server_start_failure(self):
+        self.mock_Session.return_value.get.return_value.status_code = 500
+        pact = Pact(Consumer('consumer'), Provider('provider'))
+        pact._process = Mock(spec=Popen)
+        with self.assertRaises(RuntimeError):
+            pact._wait_for_server_start()
+
+        session = self.mock_Session.return_value
+        session.mount.assert_called_once_with(
+            'http://', self.mock_HTTPAdapter.return_value)
+        session.get.assert_called_once_with(
+            'http://localhost:1234', headers={'X-Pact-Mock-Service': 'true'})
+        self.mock_HTTPAdapter.assert_called_once_with(
+            max_retries=self.mock_Retry.return_value)
+        self.mock_Retry.assert_called_once_with(total=15, backoff_factor=0.1)
+        pact._process.communicate.assert_called_once_with()
+        pact._process.terminate.assert_called_once_with()
 
 
 class PactVerifyTestCase(PactTestCase):

requirements.txt

@@ -1,3 +1,4 @@
 click==6.7
+psutil==5.2.2
 requests==2.12.3
 six==1.10.0