def pytest_report_header(config):
"""Display the api version and git commit the koku server is running under"""
koku_config = hansei_config.get_config().get('koku', {})
report_header = ""
try:
client = hansei_api.Client(username=koku_config.get('username'),
password=koku_config.get('password'))
client.server_status()
server_status = client.last_response.json()
report_header = " - API Version: {}\n - Git Commit: {}".format(
server_status['api_version'], server_status['commit'])
if config.pluginmanager.hasplugin("junitxml") and hasattr(
config, '_xml'):
config._xml.add_global_property('Koku Server Id',
server_status['server_id'])
config._xml.add_global_property('Koku API Version',
server_status['api_version'])
config._xml.add_global_property('Koku Git Commit',
server_status['commit'])
config._xml.add_global_property('Koku Python Version',
server_status['python_version'])
except HTTPError:
report_header = " - Unable to retrieve the server status"
return "Koku Server Info:\n{}".format(report_header)
def get_koku_url():
"""Return the base url for the koku server."""
cfg = get_config().get('koku', {})
hostname = cfg.get('hostname')
if not hostname:
raise exceptions.KokuBaseUrlNotFound(
'Make sure you have a "koku" section and `hostname`is specified in '
'the hansei config file')
scheme = 'https' if cfg.get('https', False) else 'http'
port = str(cfg.get('port', ''))
netloc = hostname + ':{}'.format(port) if port else hostname
return urlunparse((scheme, netloc, '', '', '', ''))
def test_api_client():
koku_cfg = config.get_config().get('koku', {})
client = api.Client(username=koku_cfg.get('username'),
password=koku_cfg.get('password'))
assert client.token, 'No token provided after logging in'
response = client.get_user()
assert response.json()['username'] == koku_cfg['username'], (
'Current user does not match expected \'admin\' user')
response = client.server_status()
assert len(response.json()) > 0, 'Server status is unavailable'
def provider(self, user):
"""Create a new KokuProvder"""
uniq_string = fauxfactory.gen_string('alphanumeric', 8)
#Grab the first AWS provider
provider_config = [
prov for prov in config.get_config().get('providers', {}) if prov['type'] == 'AWS'][0]
#TODO: Implement lazy authentication of the client for new KokuObject() fixtures
provider = user.create_provider(
name='Provider {} for user {}'.format(uniq_string, user.username),
authentication=provider_config.get('authentication'),
provider_type=provider_config.get('type'),
billing_source=provider_config.get('billing_source'))
return provider
def __init__(self, client=None, username=None, password=None):
"""
Arguments:
client - existing ``hansei.api.Client`` instance used to communicate with the Koku
server. client authenticaton credentials will be used even if username & password
are provided
username - username to use for authentication
password - password to use for authentication
"""
cfg = config.get_config().get('koku', {})
self.username = username or cfg.get('username', KOKU_DEFAULT_USER)
self.password = password or cfg.get('password', KOKU_DEFAULT_PASSWORD)
self.client = client if client else api.Client(username=self.username,
password=self.password)
self.uuid = None
def pytest_configure(config):
koku_admin = config.getoption('koku_admin_username')
koku_admin_pw = config.getoption('koku_admin_password')
koku_hostname = config.getoption('koku_hostname')
koku_host_port = config.getoption('koku_host_port')
koku_config = hansei_config.get_config().get('koku', {})
if koku_admin:
koku_config['username'] = koku_admin
if koku_admin_pw:
koku_config['password'] = koku_admin_pw
if koku_hostname:
koku_config['hostname'] = koku_hostname
if koku_host_port:
koku_config['port'] = koku_host_port
def koku_config():
return config.get_config().get('koku', {})
def __init__(self,
response_handler=None,
url=None,
authenticate=True,
username=None,
password=None):
"""Initialize this object, collecting base URL from config file.
If no response handler is specified, use the `code_handler` which will
raise an exception for 'bad' return codes.
If no URL is specified, then the config file will be parsed and the URL
will be built by reading the hostname, port and https values. You can
configure the default URL by including the following on your hansei
configuration file::
koku:
hostname: <machine_hostname_or_ip_address>
port: <port> # if not defined will take the default port
# depending on the https config: 80 if https is
# false and 443 if https is true.
https: false # change to true if server is published over
# https. Defaults to false if not defined
Arguments:
response_handler - Customer handler wrapper for formatting response
url - Url for the Koku server. Default is localhost (127.0.0.1)
authenticate - If True, login to the server during initialization
username - Username used for server authentication
password - Password used for server authentication
"""
# Stores the response of the last request made.
self._last_response = None
self.url = url
self.token = None
cfg = config.get_config().get('koku', {})
self.verify = cfg.get('ssl-verify', False)
if not self.url:
hostname = cfg.get('hostname')
if not hostname:
raise exceptions.KokuBaseUrlNotFound(
"\n'koku' section specified in hansei config file, but"
"no 'hostname' key found.")
scheme = 'https' if cfg.get('https', False) else 'http'
port = str(cfg.get('port', ''))
netloc = hostname + ':{}'.format(port) if port else hostname
self.url = urlunparse(
(scheme, netloc, KOKU_API_VERSION, '', '', ''))
if not self.url:
raise exceptions.KOKUBaseUrlNotFound(
'No base url was specified to the client either with the '
'url="host" option or with the hansei config file.')
if response_handler is None:
self.response_handler = code_handler
else:
self.response_handler = response_handler
if authenticate:
self.login(username=username, password=password)
def service_admin(self):
koku_config = config.get_config().get('koku', {})
return KokuServiceAdmin(
username=koku_config.get('username'), password=koku_config.get('password'))
