Feat/ffi provider mike

.flake8

@@ -2,3 +2,4 @@
 ignore = E226,E302,E41,W503
 max-line-length = 160
 max-complexity = 10
+exclude = venv, .tox

README.md

@@ -17,17 +17,19 @@ Note: As of Version 1.0 deprecates support for python 2.7 to allow us to incorpo
 # How to use pact-python
 
 ## Installation
+
 ```
 pip install pact-python
 ```
 
 ## Getting started
+
 <!-- Absolute link for rendering page in docs.pact.io -->
 A guide follows but if you go to the [e2e examples](https://github.com/pact-foundation/pact-python/tree/master/examples/e2e). This has a consumer, provider and pact-broker set of tests.
 
 ## Writing a Pact
 
-Creating a complete contract is a two step process:
+Creating a complete contract is a two-step process:
 
 1. Create a test on the consumer side that declares the expectations it has of the provider
 2. Create a provider state that allows the contract to pass when replayed against the provider
@@ -82,7 +84,6 @@ class GetUserInfoContract(unittest.TestCase):
       result = user('UserA')
 
     self.assertEqual(result, expected)
-
 ```
 
 This does a few important things:
@@ -164,11 +165,13 @@ The mock service offers you several important features when building your contra
 - Finally, it will record your contracts as a JSON file that you can store in your repository or publish to a Pact broker.
 
 ## Expecting Variable Content
+
 The above test works great if that user information is always static, but what happens if
 the user has a last updated field that is set to the current time every time the object is
 modified? To handle variable data and make your tests more robust, there are 3 helpful matchers:
 
 ### Term(matcher, generate)
+
 Asserts the value should match the given regular expression. You could use this
 to expect a timestamp with a particular format in the request or response where
 you know you need a particular format, but are unconcerned about the exact date:
@@ -194,6 +197,7 @@ provider, the regex will be used to search the response from the real provider s
 and the test will be considered successful if the regex finds a match in the response.
 
 ### Like(matcher)
+
 Asserts the element's type matches the matcher. For example:
 
 ```python
@@ -202,6 +206,7 @@ Like(123)  # Matches if the value is an integer
 Like('hello world')  # Matches if the value is a string
 Like(3.14)  # Matches if the value is a float
 ```
+
 The argument supplied to `Like` will be what the mock service responds with.
 
 When a dictionary is used as an argument for Like, all the child objects (and their child objects etc.) will be matched according to their types, unless you use a more specific matcher like a Term.
@@ -262,18 +267,18 @@ Format().ip_address  # Matches if the value is a ip address
 
 We've created a number of them for you to save you the time:
 
-| matcher          | description                                                                                     |
-|-----------------|-------------------------------------------------------------------------------------------------|
-| `identifier`  | Match an ID (e.g. 42)                                                                           |
-| `integer`     | Match all numbers that are integers (both ints and longs)                                       |
-| `decimal`     | Match all real numbers (floating point and decimal)                                             |
-| `hexadecimal`    | Match all hexadecimal encoded strings                                                           |
-| `date`        | Match string containing basic ISO8601 dates (e.g. 2016-01-01)                                   |
-| `timestamp`   | Match a string containing an RFC3339 formatted timestapm (e.g. Mon, 31 Oct 2016 15:21:41 -0400) |
-| `time`        | Match string containing times in ISO date format (e.g. T22:44:30.652Z)                          |
-| `ip_address` | Match string containing IP4 formatted address                                                   |
+| matcher        | description                                                                                     |
+|----------------|-------------------------------------------------------------------------------------------------|
+| `identifier`   | Match an ID (e.g. 42)                                                                           |
+| `integer`      | Match all numbers that are integers (both ints and longs)                                       |
+| `decimal`      | Match all real numbers (floating point and decimal)                                             |
+| `hexadecimal`  | Match all hexadecimal encoded strings                                                           |
+| `date`         | Match string containing basic ISO8601 dates (e.g. 2016-01-01)                                   |
+| `timestamp`    | Match a string containing an RFC3339 formatted timestamp (e.g. Mon, 31 Oct 2016 15:21:41 -0400) |
+| `time`         | Match string containing times in ISO date format (e.g. T22:44:30.652Z)                          |
+| `ip_address`   | Match string containing IP4 formatted address                                                   |
 | `ipv6_address` | Match string containing IP6 formatted address                                                   |
-| `uuid`        | Match strings containing UUIDs                                                                  |
+| `uuid`         | Match strings containing UUIDs                                                                  |
 
 These can be used to replace other matchers
 
@@ -399,18 +404,20 @@ The provider application version. Required for publishing verification results.
 Publish verification results to the broker.
 
 ### Python API
+
 You can use the Verifier class. This has all the same parameters as the cli tool but allows you to write native python code and the test framework of your choice.
 
 ```python
 verifier = Verifier(provider='UserService',
                     provider_base_url=PACT_URL)
 
 output, logs = verifier.verify_pacts('./userserviceclient-userservice.json')
-
 ```
+
 You can see more details in the [e2e examples](https://github.com/pact-foundation/pact-python/tree/master/examples/e2e/tests/provider/test_provider.py).
 
 ### Provider States
+
 In many cases, your contracts will need very specific data to exist on the provider
 to pass successfully. If you are fetching a user profile, that user needs to exist,
 if querying a list of records, one or more records needs to exist. To support
@@ -429,19 +436,20 @@ on the provider application or a separate one. Some strategies for managing stat
 For more information about provider states, refer to the [Pact documentation] on [Provider States].
 
 # Development
+
 <!-- Absolute link for rendering page in docs.pact.io -->
 Please read [CONTRIBUTING.md](https://github.com/pact-foundation/pact-python/blob/master/CONTRIBUTING.md)
 
 To setup a development environment:
 
-1. If you want to run tests for all Python versions, install 2.7, 3.3, 3.4, 3.5, and 3.6 from source or using a tool like [pyenv]
-2. Its recommended to create a Python [virtualenv] for the project.
+1. If you want to run tests for all Python versions, install 3.6, 3.7, 3.8, and 3.9 from source or using a tool like [pyenv]
+2. It's recommended to create a Python [virtualenv] for the project.
 3. We are now using FFI bindings. For mac you might want to read these [setup FFI](https://cffi.readthedocs.io/en/latest/installation.html)
 
 The setup the environment, run tests, and package the application, run:
 `make release`
 
-If you are just interested in packaging pact-python so you can install it using pip:
+If you are just interested in packaging pact-python you can install it using pip:
 
 `make package`
 

pact/ffi/pact_ffi.py

@@ -0,0 +1,58 @@
+"""Wrapper to pact reference dynamic libraries using FFI."""
+
+import platform
+
+from cffi import FFI
+
+
+class PactFFI(object):
+    """This interfaces with the Rust crate `pact_ffi`_, which exposes the Pact
+    API via a C Foreign Function Interface. In the case of python, the library
+    is then accessed using `CFFI`_.
+
+    This class will implement the shared library loading, along with a wrapper
+    for the functions provided by the base crate. For each of the Rust modules
+    exposed, a corresponding python class will extend this base class, and
+    provide the wrapper for the functions the module provides.
+
+    .. _pact_ffi:
+        https://docs.rs/pact_ffi/0.0.1/pact_ffi/index.html
+    .. _CFFI:
+        https://cffi.readthedocs.io/en/latest/
+    """
+
+    def version(self) -> str:
+        """Get the current library version.
+
+        :return: pact_ffi library version, for example "0.0.1"
+        """
+        ffi = FFI()
+        ffi.cdef(
+            """
+        char *pactffi_version(void);
+        """
+        )
+        lib = self._load_ffi_library(ffi)
+        result = lib.pactffi_version()
+
+        return ffi.string(result).decode('utf-8')
+
+    def _load_ffi_library(self, ffi):
+        """Load the appropriate library for the current platform."""
+        target_platform = platform.platform().lower()
+
+        if target_platform in ['darwin', 'macos']:
+            libname = "pact/bin/libpact_ffi-osx-x86_64.dylib"
+        elif 'linux' in target_platform:
+            libname = "pact/bin/libpact_ffi-linux-x86_64.so"
+        elif 'windows' in target_platform:
+            libname = "pact/bin/pact_ffi-windows-x86_64.dll"
+        else:
+            msg = (
+                f'Unfortunately, {platform.platform()} is not a supported '
+                f'platform. Only Linux, Windows, and OSX are currently '
+                f'supported.'
+            )
+            raise Exception(msg)
+
+        return ffi.dlopen(libname)

pact/ffi/verifier.py

@@ -0,0 +1,79 @@
+"""Wrapper to pact reference dynamic libraries using FFI."""
+import os
+import tempfile
+from enum import Enum, unique
+from typing import NamedTuple, List
+
+from cffi import FFI
+
+from pact.ffi.pact_ffi import PactFFI
+
+
+@unique
+class VerifyStatus(Enum):
+    SUCCESS = 0  # Operation succeeded
+    VERIFIER_FAILED = 1  # The verification process failed, see output for errors
+    NULL_POINTER = 2  # A null pointer was received
+    PANIC = 3  # The method panicked
+    INVALID_ARGS = 4  # Invalid arguments were provided to the verification process
+
+
+@unique
+class LogToBufferStatus(Enum):
+    SUCCESS = 0  # Operation succeeded
+    CANT_SET_LOGGER = -1  # Can't set the logger
+    NO_LOGGER = -2  # No logger has been initialized
+    SPECIFIER_NOT_UTF8 = -3  # The sink specifier was not UTF-8 encoded
+    UNKNOWN_SINK_TYPE = -4  # The sink type specified is not a known type
+    MISSING_FILE_PATH = -5  # No file path was specified in the sink specification
+    CANT_OPEN_SINK_TO_FILE = -6  # Opening a sink to the given file failed
+    CANT_CONSTRUCT_SINK = -7  # Can't construct sink
+
+
+class VerifyResult(NamedTuple):
+    return_code: VerifyStatus
+    logs: List[str]
+
+
+class Verifier(PactFFI):
+    """A Pact Verifier Wrapper.
+
+    This interfaces with the Rust FFI crate pact_ffi, specifically the
+    `verifier`_ module.
+
+    .. _verifier:
+        https://docs.rs/pact_ffi/0.0.1/pact_ffi/verifier/index.html
+    """
+
+    def verify(self, args=None) -> VerifyResult:
+        """Call verify method."""
+        ffi = FFI()
+        ffi.cdef(
+            """
+        int pactffi_verify(char *);
+        int pactffi_log_to_file(char *);
+        """
+        )
+        lib = self._load_ffi_library(ffi)
+
+        if args:
+            c_args = ffi.new('char[]', bytes(args, 'utf-8'))
+        else:
+            c_args = ffi.NULL
+
+        # This fails if called a second time after the library has been loaded
+        # ..but still seems to work
+        # result = lib.pactffi_log_to_buffer()
+        # assert LogToBufferStatus(result) == LogToBufferStatus.SUCCESS
+        # Additionally, when reading from the buffer it seems to come back empty
+        # when running normally. Storing to a temporary file, at least for now.
+        with tempfile.TemporaryDirectory() as td:
+            output = os.path.join(td, 'output')
+            output_c = ffi.new('char[]', bytes(output, 'utf-8'))
+            lib.pactffi_log_to_file(output_c)
+
+            result = lib.pactffi_verify(c_args)
+
+            lines = open(output).readlines()
+
+        return VerifyResult(result, lines)

setup.py

@@ -17,7 +17,7 @@
 
 IS_64 = sys.maxsize > 2 ** 32
 PACT_STANDALONE_VERSION = '1.88.51'
-PACT_FFI_VERSION = '0.0.0'
+PACT_FFI_VERSION = '0.0.1'
 
 here = os.path.abspath(os.path.dirname(__file__))
 
@@ -31,7 +31,7 @@ class PactPythonDevelopCommand(develop):
     Custom develop mode installer for pact-python.
 
     When the package is installed using `python setup.py develop` or
-    `pip install -e` it will download and unpack the appropriate Pact
+    `pip install -e .` it will download and unpack the appropriate Pact
     mock service and provider verifier.
     """
 
@@ -59,6 +59,7 @@ def run(self):
         install.run(self)
         bin_path = os.path.join(self.install_lib, 'pact', 'bin')
         os.mkdir(bin_path)
+
         install_ruby_app(bin_path)
         install_rust_app(bin_path)
 
@@ -102,8 +103,8 @@ def fetch_lib(bin_path, suffix, type):
     Fetch rust binaries to the bin_path.
 
     :param bin_path: The path where binaries should be installed.
-    :param suffix: The suffix filenamne unique to this platform (e.g. libpact_ffi-osx-x86_64).
-    "param type: The type of library (e.g. so|a|dll|dylib)
+    :param suffix: The suffix filename unique to this platform (e.g. libpact_ffi-osx-x86_64).
+    :param type: The type of library (e.g. so|a|dll|dylib)
     Raises:
         RuntimeError: [description]
 

tests/ffi/test_verifier.py

@@ -0,0 +1,17 @@
+from unittest import TestCase
+
+from pact.ffi.verifier import Verifier, VerifyStatus
+
+
+class VerifierTestCase(TestCase):
+    def test_version(self):
+        assert Verifier().version() == "0.0.1"
+
+    def test_verify_no_args(self):
+        result = Verifier().verify(args=None)
+        self.assertEqual(VerifyStatus(result.return_code), VerifyStatus.NULL_POINTER)
+
+    def test_verify_invalid_args(self):
+        result = Verifier().verify(args="Your argument is invalid")
+        assert VerifyStatus(result.return_code) == VerifyStatus.INVALID_ARGS
+        self.assertIn('UnknownArgument', '\n'.join(result.logs))