def test_help(self):
command = help.Show(env=environment.Environment())
output = command.execute({'<module>': None, '<command>': None})
self.assertTrue('usage: sl help' in output)
output = command.execute({'<module>': 'help', '<command>': None})
self.assertTrue('usage: sl help' in output)
output = command.execute({'<module>': 'server', '<command>': 'list'})
self.assertTrue('usage: sl server list' in output)
def setUp(self): # NOQA
testtools.TestCase.setUp(self)
self.mocks.clear()
transport = SoftLayer.XmlRpcTransport(endpoint_url=self.endpoint_url)
wrapped_transport = SoftLayer.TimingTransport(transport)
self.client = SoftLayer.BaseClient(transport=wrapped_transport)
self.env = environment.Environment()
self.env.client = self.client
self.set_up()
def test_summary(self):
command = summary.Summary(client=self.client,
env=environment.Environment())
output = command.execute({})
expected = [{'datacenter': 'dal00',
'networking': 1,
'subnets': 0,
'hardware': 1,
'IPs': 3,
'vs': 1,
'vlans': 1}]
self.assertEqual(expected, formatting.format_output(output, 'python'))
def setUp(self): # NOQA
self.env = environment.Environment()
# Create a crazy mockable, fixture client
auth = SoftLayer.BasicAuthentication('default-user', 'default-key')
self.mocks = MockableTransport(SoftLayer.FixtureTransport())
self.transport = SoftLayer.TimingTransport(self.mocks)
self.client = SoftLayer.Client(transport=self.transport,
auth=auth,
timeout=10,
endpoint_url='default-endpoint-url')
self.env.client = self.client
return self.set_up()
def main(args=sys.argv[1:], env=environment.Environment()):
"""Entry point for the command-line client."""
# Parse Top-Level Arguments
exit_status = 0
resolver = CommandParser(env)
try:
command, command_args = resolver.parse(args)
# Set logging level
debug_level = command_args.get('--debug')
if debug_level:
logger = logging.getLogger()
handler = logging.StreamHandler()
logger.addHandler(handler)
logger.setLevel(DEBUG_LOGGING_MAP.get(debug_level, logging.DEBUG))
kwargs = {
'proxy': command_args.get('--proxy'),
'config_file': command_args.get('--config')
}
if command_args.get('--timings'):
client = SoftLayer.TimedClient(**kwargs)
else:
client = SoftLayer.Client(**kwargs)
# Do the thing
runnable = command(client=client, env=env)
data = runnable.execute(command_args)
if data:
out_format = command_args.get('--format', 'table')
if out_format not in VALID_FORMATS:
raise exceptions.ArgumentError('Invalid format "%s"'
% out_format)
output = formatting.format_output(data, fmt=out_format)
if output:
env.out(output)
if command_args.get('--timings'):
out_format = command_args.get('--format', 'table')
api_calls = client.get_last_calls()
timing_table = formatting.KeyValueTable(['call', 'time'])
for call, _, duration in api_calls:
timing_table.add_row([call, duration])
env.err(formatting.format_output(timing_table, fmt=out_format))
except exceptions.InvalidCommand as ex:
env.err(resolver.get_module_help(ex.module_name))
if ex.command_name:
env.err('')
env.err(str(ex))
exit_status = 1
except exceptions.InvalidModule as ex:
env.err(resolver.get_main_help())
if ex.module_name:
env.err('')
env.err(str(ex))
exit_status = 1
except docopt.DocoptExit as ex:
env.err(ex.usage)
env.err(
'\nUnknown argument(s), use -h or --help for available options')
exit_status = 127
except KeyboardInterrupt:
env.out('')
exit_status = 1
except exceptions.CLIAbort as ex:
env.err(str(ex.message))
exit_status = ex.code
except SystemExit as ex:
exit_status = ex.code
except SoftLayer.SoftLayerAPIError as ex:
if 'invalid api token' in ex.faultString.lower():
env.out("Authentication Failed: To update your credentials, use "
"'sl config setup'")
else:
env.err(str(ex))
exit_status = 1
except SoftLayer.SoftLayerError as ex:
env.err(str(ex))
exit_status = 1
except Exception:
import traceback
env.err("An unexpected error has occured:")
env.err(traceback.format_exc())
env.err("Feel free to report this error as it is likely a bug:")
env.err(" https://github.com/softlayer/softlayer-python/issues")
exit_status = 1
sys.exit(exit_status)
def test_get_version_message(self, get_latest_version_mock):
get_latest_version_mock.return_value = '1.1.1'
env = environment.Environment()
result = self.run_command(['--version'], env=env)
self.assert_no_fail(result)
def test_build_client(self):
env = environment.Environment()
result = self.run_command(['vs', 'list'], env=env)
self.assert_no_fail(result)
self.assertIsNotNone(env.client)
def test_build_client(self):
env = environment.Environment()
result = self.run_command(['vs', 'list'], env=env)
self.assertEqual(result.exit_code, 0)
self.assertIsNotNone(env.client)
def set_up(self):
self.env = environment.Environment()
