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]
self.mock_Pid_exists.return_value = False
pact = Pact(Consumer('consumer', version='abc'),
Provider('provider'),
publish_to_broker=True,
pact_dir='some_dir')
pact._process = Mock(spec=Popen, pid=999)
pact.stop_service()
self.assertFalse(pact._process.terminate.called)
self.assertFalse(pact._process.communicate.called)
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()
self.mock_Process.return_value.wait.assert_called_once_with()
self.mock_Pid_exists.assert_called_once_with(999)
self.mock_publish.assert_called_once_with(pact,
'consumer',
'abc',
consumer_tags=None,
tag_with_git_branch=False,
pact_dir='some_dir')
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)
class ConsumerTestCase(TestCase):
def setUp(self):
self.mock_service = Mock(Pact)
self.provider = Mock(Provider)
self.consumer = Consumer('TestConsumer', service_cls=self.mock_service)
def test_init(self):
result = Consumer('TestConsumer')
self.assertIsInstance(result, Consumer)
self.assertEqual(result.name, 'TestConsumer')
self.assertIs(result.service_cls, Pact)
def test_has_pact_with(self):
result = self.consumer.has_pact_with(self.provider)
self.assertIs(result, self.mock_service.return_value)
self.mock_service.assert_called_once_with(
consumer=self.consumer, provider=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',
broker_base_url=None, publish_to_broker=False,
broker_username=None, broker_password=None,
broker_token=None, file_write_mode='overwrite')
def test_has_pact_with_customer_all_options(self):
result = self.consumer.has_pact_with(
self.provider, host_name='example.com', port=1111,
log_dir='/logs', ssl=True, sslcert='/ssl.cert', sslkey='ssl.pem',
cors=True, pact_dir='/pacts', version='3.0.0',
file_write_mode='merge')
self.assertIs(result, self.mock_service.return_value)
self.mock_service.assert_called_once_with(
consumer=self.consumer, provider=self.provider,
host_name='example.com', port=1111,
log_dir='/logs', ssl=True, sslcert='/ssl.cert', sslkey='ssl.pem',
cors=True, pact_dir='/pacts', version='3.0.0',
broker_base_url=None, publish_to_broker=False,
broker_username=None, broker_password=None, broker_token=None,
file_write_mode='merge')
def test_has_pact_with_not_a_provider(self):
with self.assertRaises(ValueError):
self.consumer.has_pact_with(None)
def setUp(self):
self.consumer = Consumer('TestConsumer')
self.provider = Provider('TestProvider')
self.addCleanup(patch.stopall)
self.mock_Popen = patch.object(broker, 'Popen', autospec=True).start()
self.mock_Popen.return_value.returncode = 0
self.mock_fnmatch = patch.object(broker.fnmatch,
'filter',
autospec=True).start()
self.mock_fnmatch.return_value = ['TestConsumer-TestProvider.json']
def test_stop_fails_posix(self):
self.mock_platform.return_value = 'Linux'
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()
pact._process.terminate.assert_called_once_with()
pact._process.communicate.assert_called_once_with()
def test_versioned_publish(self):
pact = Pact(Consumer('TestConsumer', version="1.0.0"),
self.provider,
publish_to_broker=True,
broker_base_url='http://localhost')
pact.publish()
self.mock_Popen.assert_called_once_with([
BROKER_CLIENT_PATH, 'publish', '--consumer-app-version=1.0.0',
'--broker-base-url=http://localhost',
'TestConsumer-TestProvider.json'
])
def test_git_tagged_publish(self):
pact = Pact(Consumer('TestConsumer', tag_with_git_branch=True),
self.provider,
publish_to_broker=True,
broker_base_url='http://localhost')
pact.publish()
self.mock_Popen.assert_called_once_with([
BROKER_CLIENT_PATH, 'publish', '--consumer-app-version=0.0.0',
'--broker-base-url=http://localhost',
'TestConsumer-TestProvider.json', '--tag-with-git-branch'
])
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, 'service', '--host=localhost', '--port=1234',
'--log', '/logs/pact-mock-service.log', '--pact-dir', '/pacts',
'--pact-file-write-mode', 'overwrite',
'--pact-specification-version=2.0.0', '--consumer', 'consumer',
'--provider', 'provider'
])
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=9, backoff_factor=0.1)
self.assertFalse(pact._process.communicate.called)
self.assertFalse(pact._process.terminate.called)
def test_stop_fails_windows(self):
self.mock_platform.return_value = 'Windows'
self.mock_Popen.return_value.returncode = 15
self.mock_Pid_exists.return_value = True
pact = Pact(Consumer('consumer'), Provider('provider'))
pact._process = Mock(spec=Popen, pid=999, returncode=15)
with self.assertRaises(RuntimeError):
pact.stop_service()
self.assertFalse(pact._process.terminate.called)
self.assertFalse(pact._process.communicate.called)
self.mock_Process.assert_called_once_with(999)
self.mock_Process.return_value.children.assert_called_once_with(
recursive=True)
self.mock_Process.return_value.wait.assert_called_once_with()
self.mock_Pid_exists.assert_called_once_with(999)
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]
self.mock_Pid_exists.return_value = False
pact = Pact(Consumer('consumer'), Provider('provider'))
pact._process = Mock(spec=Popen, pid=999)
pact.stop_service()
self.assertFalse(pact._process.terminate.called)
self.assertFalse(pact._process.communicate.called)
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()
self.mock_Process.return_value.wait.assert_called_once_with()
self.mock_Pid_exists.assert_called_once_with(999)
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, 'service', '--host=localhost', '--port=1234',
'--log', '/logs/pact-mock-service.log', '--pact-dir', '/pacts',
'--pact-file-write-mode', 'overwrite',
'--pact-specification-version=2.0.0', '--consumer', 'consumer',
'--provider', 'provider'
])
def test_init(self):
result = Consumer('TestConsumer')
self.assertIsInstance(result, Consumer)
self.assertEqual(result.name, 'TestConsumer')
self.assertIs(result.service_cls, Pact)
def setUp(self):
self.mock_service = Mock(Pact)
self.provider = Mock(Provider)
self.consumer = Consumer('TestConsumer', service_cls=self.mock_service)
import atexit
import requests
import unittest
from pact import EachLike, SomethingLike, Term
from pact.consumer import Consumer
from pact.provider import Provider
pact = Consumer('consumer').has_pact_with(Provider('provider'),
pact_dir='./pacts')
pact.start_service()
atexit.register(pact.stop_service)
class BaseTestCase(unittest.TestCase):
pass
class ExactMatches(BaseTestCase):
def test_get_user_sparse(self):
expected = {'name': 'Jonas'}
(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 pact:
result = requests.get('http://localhost:1234/users/Jonas')
self.assertEqual(result.json(), expected)
import atexit
import requests
import unittest
from pact import EachLike, SomethingLike, Term
from pact.consumer import Consumer
from pact.provider import Provider
pact = Consumer('consumer').has_pact_with(Provider('provider'),
host_name='mockservice',
port=1234)
pact.start_service()
atexit.register(pact.stop_service)
class BaseTestCase(unittest.TestCase):
pass
class ExactMatches(BaseTestCase):
def test_get_user_sparse(self):
expected = {
"status": "success",
"data": {
"id": "24",
"employee_name": "Doris Wilder",
"employee_salary": "85600",
"employee_age": "23",
"profile_image": ""
def setUp(self):
self.consumer = Consumer('TestConsumer')
self.provider = Provider('TestProvider')
