def before_scenario(context, step):
context.account_ids = {}
context.player_ids = {}
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
env = context.config.userdata.get('env')
context.env_urls = get_environment_variables(env)
context.clients = Dict()
context.clients.game_service = SwaggerClient.from_spec(
load_file('specs/dukedoms_game_service_api.yaml', ),
origin_url=context.env_urls.game_service,
config=config)
context.clients.account_service = SwaggerClient.from_spec(
load_file('specs/dukedoms_account_service_api.yaml', ),
origin_url=context.env_urls.account_service,
config=config)
def test_non_existent_file():
with pytest.raises(IOError) as excinfo:
load_file(os.path.join('test-data', '2.0', 'i_dont_exist.json'))
if sys.platform == "win32":
assert 'The system cannot find the file specified' in str(
excinfo.value)
else:
assert 'No such file or directory' in str(excinfo.value)
def get_client(token=None):
if token == None:
return SwaggerClient.from_spec(load_file(swagger_json_file))
# Set up client
http_client = RequestsClient()
return SwaggerClient.from_spec(load_file(swagger_json_file),
http_client=http_client)
def before_scenario(context, step):
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
context.env_urls = Dict()
context.env_urls.card_service = 'http://127.0.0.1:5005'
context.env_urls.card_service_db = (
'postgresql+psycopg2://postgres:[email protected]:5432/card_service'
)
context.clients = Dict()
context.clients.card_service = SwaggerClient.from_spec(
load_file(
'specs/dukedoms_card_service_api.yaml',
),
origin_url=context.env_urls.card_service,
config=config
)
def test_init():
client = BitJWSSwaggerClient.from_spec(load_file(specurl),
'https://0.0.0.0:8002')
assert 'coin' in client.swagger_spec.definitions
assert 'user' in client.swagger_spec.definitions
ckey = client.coin.addCoin.swagger_spec.http_client.authenticator.privkey
assert isinstance(ckey, bitjws.PrivateKey)
def setup_swagger(self):
self.http_client = RequestsClient()
self.http_client.session.verify = False
self.client = SwaggerClient.from_spec(load_file(self.spec),
config=self.config,
http_client=self.http_client)
self.client.swagger_spec.api_url = self.api_url
def setup(self):
self.http_client = RequestsClient()
self.http_client.session.verify = False
self.client = SwaggerClient.from_spec(load_file('management_api.yml'),
config=self.config,
http_client=self.http_client)
self.client.swagger_spec.api_url = "http://%s/api/%s/" % (
pytest.config.getoption("host"), pytest.config.getoption("api"))
def setup_swagger(self):
self.http_client = RequestsClient()
self.http_client.session.verify = False
spec = pytest.config.getoption(self.spec_option)
self.client = SwaggerClient.from_spec(load_file(spec),
config=self.config,
http_client=self.http_client)
self.client.swagger_spec.api_url = self.make_api_url()
def before_scenario(context, step):
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
context.urls = get_env_urls(context.config.userdata.get('env'))
context.clients = Dict()
context.clients.action_broker = SwaggerClient.from_spec(
load_file(
'swagger/action_broker_api.yaml',
),
origin_url=context.urls.action_broker,
config=config
)
context.clients.card_broker = SwaggerClient.from_spec(
load_file(
'swagger/card_broker_api.yaml',
),
origin_url=context.urls.card_broker,
config=config
)
context.clients.card_service = SwaggerClient.from_spec(
load_file(
'swagger/card_service_api.yaml',
),
origin_url=context.urls.card_service,
config=config
)
context.clients.player_service = SwaggerClient.from_spec(
load_file(
'swagger/player_service_api.yaml',
),
origin_url=context.urls.player_service,
config=config
)
def setup_swagger(self):
self.http_client = RequestsClient()
self.http_client.session.verify = False
spec = pytest.config.getoption(self.spec_option)
self.client = SwaggerClient.from_spec(load_file(spec),
config=self.config,
http_client=self.http_client)
self.client.swagger_spec.api_url = "http://{}/api/{}/".format(pytest.config.getoption("host"),
pytest.config.getoption("api"))
def setup(self):
self.log = logging.getLogger("client.Client")
self.api_url = API_URL
self.http_client = RequestsClient()
self.http_client.session.verify = False
spec = pytest.config.getoption("spec")
self.client = SwaggerClient.from_spec(load_file(spec),
config=self.config,
http_client=self.http_client)
self.client.swagger_spec.api_url = self.api_url
def test_init_PrivateKey():
privkey = bitjws.PrivateKey(bitjws.wif_to_privkey(wif))
client = BitJWSSwaggerClient.from_spec(load_file(specurl),
'https://0.0.0.0:8002',
privkey=privkey)
assert 'coin' in client.swagger_spec.definitions
assert 'user' in client.swagger_spec.definitions
ckey = client.coin.addCoin.swagger_spec.http_client.authenticator.privkey
assert isinstance(ckey, bitjws.PrivateKey)
assert bitjws.privkey_to_wif(privkey.private_key) == \
bitjws.privkey_to_wif(ckey.private_key)
def pod_cg(self, url):
http_client = RequestsClient()
self.__url__ = url
assert http_client
# load deprecated agent codegen objects from spec
try:
pod = SwaggerClient.from_spec(load_file(self.pod_swagger),
config={'also_return_response': True})
pod.swagger_spec.api_url = self.__url__
except Exception as err:
self.logger.error(err)
return pod
def __init__(self, apikey=None):
http_client = None
if apikey:
http_client = RequestsClient()
http_client.set_api_key('www.openml.org',
apikey,
param_name='api_key',
param_in='header')
file_path = os.path.abspath(__file__)
src_path = os.path.join(os.path.dirname(file_path), '..')
api_defs = os.path.join(src_path, 'swagger.yml')
self.client = SwaggerClient.from_spec(load_file(api_defs),
http_client=http_client)
def setup_swagger(self, host, swagger_spec):
config = {
"also_return_response": True,
"validate_responses": True,
"validate_requests": False,
"validate_swagger_spec": False,
"use_models": True,
}
self.http_client = RequestsClient()
self.http_client.session.verify = False
self.client = SwaggerClient.from_spec(load_file(swagger_spec),
config=config,
http_client=self.http_client)
self.client.swagger_spec.api_url = self.api_url
def test_init_url_WIF():
url = "http://spec.com/swagger.json"
spec = load_file(specurl)
httpretty.enable()
httpretty.register_uri(httpretty.GET, url,
body=json.dumps(spec))
client = BitJWSSwaggerClient.from_url(url, privkey=wif)
assert 'coin' in client.swagger_spec.definitions
assert 'user' in client.swagger_spec.definitions
ckey = client.coin.addCoin.swagger_spec.http_client.authenticator.privkey
assert isinstance(ckey, bitjws.PrivateKey)
assert wif == bitjws.privkey_to_wif(ckey.private_key)
httpretty.disable()
httpretty.reset()
def before_scenario(context, step):
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
context.clients = Dict()
context.clients.card_service = SwaggerClient.from_spec(
load_file('specs/mock_card_service_api.yaml', ),
origin_url='http://127.0.0.1:5005',
config=config)
def get_client():
access_token = "Bearer " + get_token()
http_client = RequestsClient()
http_client.set_api_key(
'api.test.sabre.com', access_token,
param_name='Authorization', param_in='header'
)
resource_package = __name__
resource_path = '/swagger.yaml' # Do not use os.path.join()
swagger_path = pkg_resources.resource_filename(resource_package, resource_path)
return SwaggerClient.from_spec(load_file(swagger_path),
http_client=http_client,
# config={'also_return_response': True}
)
def _add_swagger(self, service_name, service_url):
# create client
# Fix bravado URL. By default Bravado ignores non-host parts of the input
# URL if the spec base path is defined. We want the path from the URL plus
# the spec's base path.
spec_dict = load_file(
os.path.join(self.spec_dir_absolute_path, service_name + '.json'))
base_path = (urlparse(service_url).path.rstrip('/') +
spec_dict.get('basePath', ''))
if base_path:
spec_dict['basePath'] = base_path
swagger_client = SwaggerClient.from_spec(spec_dict,
origin_url=service_url,
config=self.bravado_config)
setattr(self, service_name, swagger_client)
def test_good_call():
url = "http://0.0.0.0:8002/coin"
bjauth = BitJWSAuthenticator("0.0.0.0", privkey=wif)
client = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url, privkey=wif)
coin = [{"metal": "m", "mint": "n"}]
data = bitjws.sign_serialize(bjauth.privkey, requrl="/response", iat=time.time(), data=coin)
httpretty.enable()
httpretty.register_uri(httpretty.GET, url, body=data, content_type="application/jose")
resp = client.coin.findCoin().result()
assert resp[0].metal == coin[0]["metal"]
assert resp[0].mint == coin[0]["mint"]
assert httpretty.last_request().headers["content-type"] == "application/jose"
httpretty.disable()
httpretty.reset()
def __init__(self,
refresh_token=None,
api_token=None,
host='app.rasterfoundry.com',
scheme='https'):
"""Instantiate an API object to make requests to Raster Foundry's REST API
Args:
refresh_token (str): optional token used to obtain an API token to
make API requests
api_token (str): optional token used to authenticate API requests
host (str): optional host to use to make API requests against
scheme (str): optional scheme to override making requests with
"""
self.http = RequestsClient()
self.scheme = scheme
if urlparse(SPEC_PATH).netloc:
spec = load_url(SPEC_PATH)
else:
spec = load_file(SPEC_PATH)
self.app_host = host
spec['host'] = host
spec['schemes'] = [scheme]
split_host = host.split('.')
split_host[0] = 'tiles'
self.tile_host = '.'.join(split_host)
config = {'validate_responses': False}
self.client = SwaggerClient.from_spec(spec,
http_client=self.http,
config=config)
if refresh_token and not api_token:
api_token = self.get_api_token(refresh_token)
elif not api_token:
raise Exception('Must provide either a refresh token or API token')
self.api_token = api_token
self.http.session.headers['Authorization'] = 'Bearer {}'.format(
api_token)
def test_spec_internal_representation_identical():
spec_json = load_file('test-data/2.0/petstore/swagger.json')
spec_yaml = load_file('test-data/2.0/petstore/swagger.yaml')
assert spec_yaml == spec_json
def swagger_client(request):
return SwaggerClient.from_spec(
spec_dict=load_file('test-data/2.0/simple/swagger.json'),
http_client=request.param,
)
def test_equality_of_different_swagger_clients(swagger_client):
assert not swagger_client.is_equal(
SwaggerClient.from_spec(
spec_dict=load_file('test-data/2.0/petstore/swagger.json')), )
def test_success():
spec_json = load_file('test-data/2.0/simple/swagger.json')
assert '2.0' == spec_json['swagger']
def client():
client = SwaggerClient.from_spec(load_file("swagger.yaml"))
return client
import os
from bravado.client import SwaggerClient
from bravado.swagger_model import load_file
from account_service.constants import URLS
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
if os.environ.get('ACCOUNT_SERVICE_ENV') == 'local':
env = 'local'
else:
env= 'container'
game_service_client = SwaggerClient.from_spec(
load_file(
'swagger/game_service_api.yaml',
),
origin_url=URLS[env].game_service,
config=config
)
class Client(object):
config = {
'also_return_response': True,
'validate_responses': False,
'validate_requests': False,
'validate_swagger_spec': True,
'use_models': True,
}
http_client = RequestsClient()
http_client.session.verify = False
client = SwaggerClient.from_spec(load_file('management_api.yml'),
config=config,
http_client=http_client)
client.swagger_spec.api_url = "http://%s/api/%s" % (
pytest.config.getoption("host"), pytest.config.getoption("api"))
group = client.get_model("Group")
deviceNew = client.get_model("DeviceNew")
inventoryAttribute = client.get_model("Attribute")
def getInventoryListFromFile(self, filename="inventory_items"):
attributeList = []
with open(filename) as inf:
r = csv.reader(inf)
for row in r:
n, v, d = row[0], row[1], row[2] if len(row) == 3 else None
# does it matter if you pass a field name = None?
attributeList.append(
self.inventoryAttribute(name=n, value=v, description=d))
return attributeList
def createDevice(self,
attributes,
deviceid=None,
description="test device"):
if not deviceid:
deviceid = "".join([format(i, "02x") for i in os.urandom(128)])
deviceNew = self.deviceNew(id=deviceid,
description=description,
attributes=attributes)
r, h = self.client.devices.post_devices(device=deviceNew,
Authorization="foo").result()
return deviceid
def deleteAllGroups(self):
groups = self.client.groups.get_groups().result()[0]
for g in groups:
for d in self.getGroupDevices(g):
self.deleteDeviceInGroup(g, d)
def getAllDevices(self, page=1, sort=None, has_group=None):
r, h = self.client.devices.get_devices(page=page,
sort=sort,
has_group=has_group,
Authorization="foo").result()
for i in parse_header_links(h.headers["link"]):
if i["rel"] == "next":
page = int(
dict(urlparse.parse_qs(urlparse.urlsplit(
i["url"]).query))["page"][0])
return r + self.getAllDevices(page=page, sort=sort)
else:
return r
def getAllGroups(self):
r, _ = self.client.groups.get_groups().result()
return r
def getGroupDevices(self, group, expected_error=False):
try:
r = self.client.groups.get_groups_name_devices(
name=group, Authorization=False).result()
except Exception as e:
if expected_error:
return []
else:
pytest.fail()
else:
return r[0]
def deleteDeviceInGroup(self, group, device, expected_error=False):
try:
r = self.client.devices.delete_devices_id_group_name(
id=device, name=group, Authorization=False).result()
except Exception:
if expected_error:
return []
else:
pytest.fail()
else:
return r
def addDeviceToGroup(self, group, device, expected_error=False):
try:
r = self.client.devices.put_devices_id_group(
group=group, id=device, Authorization=False).result()
except Exception:
if expected_error:
return []
else:
pytest.fail()
else:
return r
def verifyInventory(self, inventoryItems, expected_data=None):
if isinstance(expected_data, str):
expectedInventoryItems = self.getInventoryListFromFile(
expected_data)
elif isinstance(expected_data, dict):
expectedInventoryItems = []
for k in expected_data.keys():
expectedInventoryItems.append(
self.inventoryAttribute(name=k, value=expected_data[k]))
assert len(inventoryItems) == len(expected_data)
for e in expected_data:
if e not in inventoryItems:
assert False, "Inventory data is incorrect"
import bitjws
from bravado.swagger_model import load_file
from bravado_bitjws.client import BitJWSSwaggerClient
from desw import CFG, ses, wm
from desw.plugin import internal_credit, internal_address
host = "0.0.0.0"
url = "http://0.0.0.0:8002/"
specurl = os.path.abspath('../desw/desw/static/swagger.json')
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
username = str(my_address)[0:8]
client = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser = client.get_model('User')(username=username)
user = client.user.addUser(user=luser).result().user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser2 = client2.get_model('User')(username=username2)
user2 = client2.user.addUser(user=luser2).result().user
def test_address():
addy = client.get_model('Address')(currency='BTC', network='Internal')
address = client.address.createAddress(address=addy).result()
import time
from bravado_bitjws.client import BitJWSSwaggerClient
from desw import CFG, ses, eng, models
from desw.plugin import internal_credit, internal_address, internal_confirm_credit
from bravado.swagger_model import load_file
host = "0.0.0.0"
url = "http://0.0.0.0:8002/"
specurl = os.path.abspath('../desw/desw/static/swagger.json')
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
username = str(my_address)[0:8]
client = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser = client.get_model('User')(username=username)
user = client.user.addUser(user=luser).result().user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser2 = client2.get_model('User')(username=username2)
user2 = client2.user.addUser(user=luser2).result().user
def test_addresses():
addy = client.get_model('Address')(currency='BTC', network='Internal')
address = client.address.createAddress(address=addy).result()
def create_client(config={}):
client = SwaggerClient.from_spec(load_file(
os.path.join(ROOT, 'static/v1/sw.yaml')),
config=dict(CLIENT_CONFIG_DEFAULTS,
**config))
return client
def test_success_yaml(filename):
spec_yaml = load_file(filename)
assert '2.0' == spec_yaml['swagger']
config = {
'also_return_response': True,
'validate_responses': True,
'validate_requests': True,
'validate_swagger_spec': True,
'use_models': True,
'formats': []
}
if os.environ.get('GAME_SERVICE_ENV') == 'local':
env = 'local'
else:
env= 'container'
account_service_client = SwaggerClient.from_spec(
load_file(
'swagger/account_service_api.yaml',
),
origin_url=URLS[env].account_service,
config=config
)
player_service_client = SwaggerClient.from_spec(
load_file(
'swagger/player_service_api.yaml',
),
origin_url=URLS[env].player_service,
config=config
)
class ManagementClient:
config = {
"also_return_response": True,
"validate_responses": False,
"validate_requests": False,
"validate_swagger_spec": True,
"use_models": True,
}
http_client = RequestsClient()
http_client.session.verify = False
client = SwaggerClient.from_spec(
load_file(pytest.config.getoption("--management-spec")),
config=config,
http_client=http_client,
)
client.swagger_spec.api_url = "http://%s/api/%s" % (
pytest.config.getoption("host"),
pytest.config.getoption("api"),
)
group = client.get_model("Group")
inventoryAttribute = client.get_model("Attribute")
log = logging.getLogger("Client")
def deleteAllGroups(self):
groups = self.client.Management_API.List_Groups().result()[0]
for g in groups:
for d in self.getGroupDevices(g):
self.deleteDeviceInGroup(g, d)
def getAllDevices(self,
page=1,
sort=None,
has_group=None,
JWT="foo.bar.baz"):
if not JWT.startswith("Bearer "):
JWT = "Bearer " + JWT
r, h = self.client.Management_API.List_Device_Inventories(
page=page, sort=sort, has_group=has_group,
Authorization=JWT).result()
for i in parse_header_links(h.headers["link"]):
if i["rel"] == "next":
page = int(
dict(urlparse.parse_qs(urlparse.urlsplit(
i["url"]).query))["page"][0])
return r + self.getAllDevices(page=page, sort=sort)
else:
return r
def getDevice(self, device_id, Authorization="foo"):
if not Authorization.startswith("Bearer "):
Authorization = "Bearer " + Authorization
r, _ = self.client.Management_API.Get_Device_Inventory(
id=device_id, Authorization=Authorization).result()
return r
def getAllGroups(self):
r, _ = self.client.Management_API.List_Groups().result()
return r
def getGroupDevices(self, group, expected_error=False):
try:
r = self.client.Management_API.Get_Devices_in_Group(
name=group, Authorization=False).result()
except Exception as e:
if expected_error:
return []
else:
pytest.fail()
else:
return r[0]
def deleteDeviceInGroup(self, group, device, expected_error=False):
try:
r = self.client.Management_API.Clear_Group(
id=device, name=group, Authorization=False).result()
except Exception:
if expected_error:
return []
else:
pytest.fail()
else:
return r
def addDeviceToGroup(self,
group,
device,
expected_error=False,
JWT="foo.bar.baz"):
if not JWT.startswith("Bearer "):
JWT = "Bearer " + JWT
try:
r = self.client.Management_API.Assign_Group(
group=group, id=device, Authorization=JWT).result()
except Exception:
if expected_error:
return []
else:
pytest.fail()
else:
return r
def test_success_yaml(filename):
spec_yaml = load_file(filename)
assert '2.0' == spec_yaml['swagger']
def test_non_existent_file():
with pytest.raises(IOError) as excinfo:
load_file('test-data/2.0/i_dont_exist.json')
assert 'No such file or directory' in str(excinfo.value)
from requests.exceptions import HTTPError, Timeout, ConnectionError
from bravado.client import SwaggerClient
from bravado.fido_client import FidoClient
from bravado.swagger_model import load_file
from bravado.exception import HTTPServerError, HTTPNotFound, HTTPForbidden, HTTPUnauthorized, HTTPError, HTTPClientError
from xml.etree import cElementTree as ET
from pprint import PrettyPrinter
from config import *
pprinter = PrettyPrinter()
for retry in range(5):
try:
esi_client = SwaggerClient.from_spec(
load_file('esi.json'),
config={'also_return_response': True},
http_client=FidoClient())
xml_client = requests.Session()
break
except (HTTPServerError, HTTPNotFound), e:
if retry < 4:
print('Attempt #{} - {}'.format(retry, e))
time.sleep(60)
continue
raise
def name_to_id(name, name_type):
name_id = esi_api('Search.get_search',
categories=[name_type],
def test_spec_internal_representation_identical():
spec_json = load_file('test-data/2.0/petstore/swagger.json')
spec_yaml = load_file('test-data/2.0/petstore/swagger.yaml')
assert spec_yaml == spec_json
def test_success():
spec_json = load_file('test-data/2.0/simple/swagger.json')
assert '2.0' == spec_json['swagger']