Merge pull request #3 from jn9e9/simple-mock

initial version of mock service.

Author: ionut-arm

README.md

@@ -15,7 +15,19 @@ pip install -r requirements.txt
 ```
 # Usage
 ## Run Mock Service
-**TBD**
+
+Currently the mock service only supports running test cases from a folder in a request matching mode.  To run the service:
+
+```bash
+# To get help
+python parsec-mock.py --help
+# To define test case folder (defaults to ./testdata)
+python parsec-mock.py --test-folder FOLDER_NAME
+# To define the unix socket address to listen to.  Defaults to ./parsec.sock
+python parsec-mock.py --parsec-socket SOCKET_ADDRESS
+```
+
+In request matching mode, the mock service loads all the test cases from the folder and, if it receives a request that matches the (base 64 decoded) test_data.request field in the test case file, it will repond with the base 64 decoded data in the test_data.response field.  If more than one test case shares the same test_data.request value, then the last one to be loaded will be used.
 
 ## Generate Test Data
 To generate test data from test specs, run 
@@ -157,7 +169,15 @@ The whole test spec is defined in the spec: object in the file.  In that spec, t
 | response.auth.type | This can either be ```none```, which will cause the auth section of the message to be empty (equivalent of the No Authentication type of authentication); or it can be ```direct```, which will cause the auth section of the message to contain authentication data corresponding to the format for Direct Authentication.  If ```direct``` is set, then the result.auth.app_name field must be set.  Note that this field does not cause the header auth_type field to be set.  **NOTE:**  A Parsec client would not send authentication data in a result message, but this spec format allows test authors to create the message as they wish to excersice the parsec client code. |
 | response.auth.app_name | Used to populate the auth section of the message when ```direct``` authentication is selected |
 
+# Mock service testing
+
+There is a very simple test for the mock service in the test folder.  Run this from the current folder:
+
+```bash
+python ./test/mock_test.py
+```
 
+This expects the mock service to be listening on ./parsec.sock and to have the testdata/ping_no_auth.test.yaml test spec loaded
 
 # License
 

parsec-mock.py

@@ -1,2 +1,94 @@
 # Copyright 2021 Contributors to the Parsec project.
 # SPDX-License-Identifier: Apache-2.0
+import click
+
+import socket
+import os
+from os import listdir
+from os.path import isfile, join
+
+import base64
+
+from yaml import safe_load
+
+
+@click.command()
+@click.option('--test-folder', default='./testdata', help='Load all tests from folder')
+@click.option('--parsec-socket', default='./parsec.sock', help='Path to parsec unix socket')
+def run_test(test_folder, parsec_socket):
+    print('Mock parsec service listening on unix://{}.'.format(parsec_socket))
+
+    test_cases = load_tests_from_folder(test_folder)
+
+    print('Serving all {} tests in folder {}'.format(len(test_cases),test_folder))
+
+    # Make sure socket doesn't already exist
+    try:
+        os.unlink(parsec_socket)
+    except OSError:
+        if os.path.exists(parsec_socket):
+            print('Error removing old parsec socket, exiting')
+            return
+
+    # Create a unix socket
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(parsec_socket)
+
+    sock.listen(1)
+
+    while True:
+        connection, client_addr = sock.accept()
+        try:
+            print('Connection received from {}'.format(client_addr))
+            received_data = connection.recv(4096)
+            b64_received_data = base64.b64encode(received_data).decode('ascii')
+            if b64_received_data in test_cases:
+                test_case = test_cases[b64_received_data]
+                print('Received expected request for test case {}'.format(test_case.spec.name))
+                bin_response = base64.b64decode(test_case.test_data.response)
+                connection.sendall(bin_response)
+            else:
+                print('Received unexpected request {}'.format(b64_received_data))
+        finally:
+            connection.close()
+
+
+class TestSpec(object):
+    """Class to represent a test specification.  Used to convert
+    dictionary created by pyaml to object format, making code easier to read."""
+
+    def __init__(self, dictionary):
+        def _traverse(key, element):
+            if isinstance(element, dict):
+                return key, TestSpec(element)
+            else:
+                return key, element
+
+        objd = dict(_traverse(k, v) for k, v in dictionary.items())
+        self.__dict__.update(objd)
+        self.basedict = dictionary
+
+    def is_valid(self):
+        return True
+
+
+def load_tests_from_folder(test_folder):
+    tests = {}
+    """Read test specs from a folder"""
+    specfiles = [f for f in listdir(test_folder) if isfile(join(test_folder, f))]
+
+    for file in specfiles:
+        print(f"Parsing spec file: {file}")
+        with open(os.path.join(test_folder, file), 'r') as f:
+            spec = safe_load(f)
+            testspec = TestSpec(spec)
+            if testspec.is_valid():
+                tests[testspec.test_data.request] = testspec
+            else:
+                print(f"Error loading test spec from {file}")
+
+    return tests
+
+
+if __name__ == "__main__":
+    run_test()

requirements.txt

@@ -1,6 +1,18 @@
-# Copyright 2021 Contributors to the Parsec project.
-# SPDX-License-Identifier: Apache-2.0
+attrs==20.3.0
+click==7.1.2
+flake8==3.9.0
+iniconfig==1.1.1
+mccabe==0.6.1
+packaging==20.9
+pluggy==0.13.1
 protobuf==3.15.6
+py==1.10.0
 pyaml==20.4.0
+pycodestyle==2.7.0
+pyflakes==2.3.1
+pyparsing==2.4.7
+pytest==6.2.2
 PyYAML==5.4.1
+rope==0.18.0
 six==1.15.0
+toml==0.10.2

test/mock_test.py

@@ -0,0 +1,33 @@
+import socket
+
+import base64
+
+# Create a UDS socket
+sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+
+# Connect the socket to the port where the server is listening
+server_address = './parsec.sock'
+print('connecting to %s' % server_address)
+
+sock.connect(server_address)
+
+try:
+    # Send data
+    message = 'EKfAXh4AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAA'
+    bin_message = base64.b64decode(message)
+
+    expected_response = 'EKfAXh4AAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAEAAAAAAAAACAE='
+    bin_expected = base64.b64decode(expected_response)
+
+    print('sending "%s"' % message)
+    sock.sendall(bin_message)
+
+    received_data = sock.recv(4096)
+    print('received {}'.format(base64.b64encode(received_data).decode('ascii')))
+    if bin_expected == received_data:
+        print('Received expected response')
+    else:
+        print('Did not get expected response')
+finally:
+    print('closing socket')
+    sock.close()