def test_v2(): pact = Consumer('consumer').has_pact_with(Provider('provider'), version='2.0.0') pact.given("the condition exists").upon_receiving("a request").with_request("GET", "/path") \ .will_respond_with(200, body='ok') result = pact.construct_pact(pact._interactions[0]) assert result == { 'consumer': { 'name': 'consumer' }, 'provider': { 'name': 'provider' }, 'interactions': [{ 'description': 'a request', 'providerState': 'the condition exists', 'request': dict(method='GET', path='/path'), 'response': dict(status=200, body='ok'), }], 'metadata': dict(pactSpecification=dict(version='2.0.0')) }
def test_full_payload_v2(): pact = Consumer('consumer').has_pact_with(Provider('provider'), version='2.0.0') (pact .given('UserA exists and is not an administrator') .upon_receiving('a request for UserA') .with_request('get', '/users/UserA', headers={'Accept': 'application/json'}, query='term=test') .will_respond_with(200, body={'username': '******'}, headers={'Content-Type': 'application/json'})) result = pact.construct_pact(pact._interactions[0]) assert result == { 'consumer': {'name': 'consumer'}, 'provider': {'name': 'provider'}, 'interactions': [ { 'description': 'a request for UserA', 'providerState': 'UserA exists and is not an administrator', 'request': dict(method='get', path='/users/UserA', headers={'Accept': 'application/json'}, query='term=test'), 'response': dict(status=200, body={'username': '******'}, headers={'Content-Type': 'application/json'}) } ], 'metadata': dict(pactSpecification=dict(version='2.0.0')) }
def test_v2(): pact = Consumer("consumer").has_pact_with(Provider("provider"), version="2.0.0") pact.given("the condition exists").upon_receiving( "a request").with_request("GET", "/path").will_respond_with(200, body="ok") result = pact.construct_pact(pact._interactions[0]) assert result == { "consumer": { "name": "consumer" }, "provider": { "name": "provider" }, "interactions": [{ "description": "a request", "providerState": "the condition exists", "request": dict(method="GET", path="/path"), "response": dict(status=200, body="ok"), }], "metadata": dict(pactSpecification=dict(version="2.0.0")), }
from RDS import Token, OAuth2Token, User, LoginService, OAuth2Service, Util def create_app(): from src import bootstrap # creates a test client app = bootstrap(use_default_error=True, testing=True).app return app pact_host_port = 3000 pact_host_fqdn = f"http://localhost:{pact_host_port}" pact = Consumer("CentralServiceTokenStorage").has_pact_with( Provider("OAuth-Provider"), port=pact_host_port) class TestTokenStorageServer(unittest.TestCase): def setUp(self): self.app = create_app() self.client = self.app.test_client() self.empty_storage = Storage() self.success = {"success": True} self.user1 = User("Max Mustermann") self.user2 = User("Mimi Mimikri") self.user3 = User("Karla Kolumda")
def test_v2_not_allowed(): with pytest.raises(Equals.NotAllowed): Consumer('C').has_pact_with(Provider('P'), version='2.0.0') \ .given("g").upon_receiving("r").with_request("post", "/foo", body=Equals("bee")) \ .will_respond_with(200)
import unittest from lib.Service import Service from pactman import Consumer, Provider import json from RDS import FileTransferArchive, FileTransferMode pact = Consumer("ServiceExporter").has_pact_with(Provider("Zenodo"), port=3000) testingaddress = "http://localhost:3000" class Test_Service(unittest.TestCase): @staticmethod def requestStorageFolderGET(pact, folderpath: str, userId: str, files: list): pact.given( f"user {userId} has {len(files)} files in folderpath {folderpath}" ).upon_receiving( "the filepaths for files in folder with folderpath" ).with_request( "GET", f"/storage/folder" ).will_respond_with( 200, body={"files": files} ) @staticmethod def requestStorageFileGET( pact, filepath: str, userId: str, fileContent: str, code=200 ): pact.given(f"user {userId} has a file in filepath {filepath}").upon_receiving( "the filecontent of the given filepath" ).with_request("GET", f"/storage/file").will_respond_with( code, body=fileContent
api_key = os.getenv("ZENODO_API_KEY", default=None) def create_app(): from src import bootstrap # creates a test client app = bootstrap(use_default_error=True, address="http://localhost:3000").app # propagate the exceptions to the test client app.config.update({"TESTING": True}) return app pact = Consumer("PortZenodo").has_pact_with(Provider("Zenodo"), port=3000) unittest.TestCase.maxDiff = None class TestPortZenodo(unittest.TestCase): def setUp(self): self.app = create_app() self.client = self.app.test_client() @classmethod def tearDownClass(cls): pass def tearDown(self): pass
from .test_service import Test_Service def create_app(): testing_address = "http://localhost:3000" from src import bootstrap # creates a test client app = bootstrap(use_default_error=True).app # propagate the exceptions to the test client app.config.update({"TESTING": testing_address}) return app pact = Consumer('ServiceExporter').has_pact_with(Provider('Zenodo'), port=3000) unittest.TestCase.maxDiff = None class TestServiceExporter(unittest.TestCase): def setUp(self): self.app = create_app() self.client = self.app.test_client() def test_files(self): userId = "admin" researchIndex = 1 userId = "admin" researchIndex = 1
import atexit import pytest import requests from pactman import Consumer, Provider #from pact import Consumer, Provider #pact = Consumer('buildReader').has_pact_with(Provider('bringon')) #pact.start_service() #atexit.register(pact.stop_service) pact = Consumer('Consumer').has_pact_with(Provider('Provider'), version='3.0.0') def test_interaction(): pact.given("some data exists").upon_receiving("a request") \ .with_request("get", "/", query={"foo": ["bar"]}).will_respond_with(200) with pact: requests.get(pact.uri, params={"foo": ["bar"]}) def test_server_is_up(): pact.given("The Server is online").upon_receiving("a request") \ .with_request("get", "/", headers={'Content-Type': 'application/json'}) \ .will_respond_with(200, body= 'Server Works!', headers={'Content-Type': 'application/json'}) with pact: r = requests.get(pact.uri, headers={'Content-Type': 'application/json'}) print (r.text)
from lib.Research import Research from pactman import Consumer, Provider import unittest pact = Consumer('UseCaseMetadataResearch').has_pact_with( Provider('PortMetadata'), port=3000) testing_address = "localhost:3000" class Test_Research(unittest.TestCase): def test_research_init_researchId(self): userId = 0 researchIndex = 0 researchId = 1 ports = [ # no entries [], # one entry [{ "port": "port-zenodo", "properties": [{ "portType": "metadata", "value": True }] }], # two entries [{ "port": "port-zenodo", "properties": [{
import unittest from lib.ownCloudUser import OwncloudUser from pactman import Consumer, Provider from urllib.parse import quote import atexit pact_host_port = 3000 pact_host_fqdn = f"http://*****:*****@unittest.skip("This does not work currently") def test_getSimpleFile(self): expected_user = "******"
return node project_node = _build_node("nodes") def create_app(): from src import bootstrap # creates a test client app = bootstrap(use_default_error=True, address="http://*****:*****@unittest.skip("not implemented") def test_project_index(self): pass
from lib.Metadata import Metadata from pactman import Consumer, Provider import unittest import json from RDS import OAuth2Service, OAuth2Token, User, Util pact = Consumer('UseCaseMetadata').has_pact_with(Provider('PortMetadata'), port=3000) testing_address = "localhost:3000" unittest.TestCase.maxDiff = None Util.monkeypatch() class Test_Metadata(unittest.TestCase): def setUp(self): self.user1 = User("MaxMustermann") self.service1 = OAuth2Service( servicename="TestService", implements=["metadata"], authorize_url="http://localhost/oauth/authorize", refresh_url="http://localhost/oauth/token", client_id="MNO", client_secret="UVW") self.token1 = OAuth2Token(self.user1, self.service1, "ABC", "X_ABC") def test_metadata_init(self): """ This unit tests the metadata object constructor.
app = bootstrap( use_optimizer={ "compress": False, "minify": False }, use_default_error=True, testing=address, ).app # propagate the exceptions to the test client app.config.update({"TESTING": True}) return app pact = Consumer("UseCaseTokenStorage").has_pact_with( Provider("CentralServiceTokenStorage"), port=3000) class Test_TokenServiceServer(unittest.TestCase): def run(self, result=None): # this make pact as context in every test available. with pact as p: super(Test_TokenServiceServer, self).run(result) def setUp(self): self.app = create_app() self.client = self.app.test_client() def test_redirect(self): code = "XYZABC" user = User("user")
import unittest from lib.ExporterService import ExporterService from pactman import Consumer, Provider def create_app(): from src import bootstrap # creates a test client app = bootstrap(use_default_error=True).app # propagate the exceptions to the test client app.config.update({"TESTING": True, "TESTSERVER": "http://localhost:3000"}) return app pact = Consumer('PortZenodo').has_pact_with(Provider('Zenodo'), port=3000) class Test_ExporterService(unittest.TestCase): def setUp(self): self.app = create_app() self.client = self.app.test_client() @unittest.skip def test_export_zenodo_from_owncloud_working(self): exporter = ExporterService( testing=True, testing_address=self.app.config.get("TESTSERVER")) # call to get file from owncloud pact.given('file and userid are valid').upon_receiving( 'the wanted file content').with_request(
import atexit import unittest import requests from pactman import Consumer, Provider, Term, Like from pactman.verifier.pytest_plugin import pact_verifier pact = Consumer('Consumer').has_pact_with( Provider('Provider'), file_write_mode="override", use_mocking_server=False, pact_dir="C:\\Users\\abdulsha\\PycharmProjects\\pact-python-master\\Pacts") # pact.start_mocking() # atexit.register(pact.stop_mocking) class Generate_POC_PACTS(unittest.TestCase): def test_generate_pact_from_consumer_end(self): # Setting up Expected Response expected = {'skip': 0, 'limit': 150} pact.given('A Support User exists and is not an administrator' ).upon_receiving('a request for API support').with_request( method='GET', path='/api', ).will_respond_with(200, body=expected) # When a request is hit to Server, would it retrieve the expected data with pact: result = requests.get(pact.uri + '/api')
import atexit import unittest from pactman import Consumer, Provider, Like from movies_api.main import get_duration, post_duration pact = Consumer('movies-api').has_pact_with(Provider('duration-provider'), port=9000, log_dir='./movies_api/logs', pact_dir='./movies_api/pacts') pact.start_service() atexit.register(pact.stop_service) class DurationContract(unittest.TestCase): def test_get_duration(self): expected = { "id": 42, "duration_min": 192, } expected_pact = Like(expected) pact.given('Given a movie exists').upon_receiving( 'a request for movies-api').with_request( 'GET', '/duration/42').will_respond_with(200, body=expected_pact) with pact: result = get_duration(42) self.assertEqual(result, expected)