def setUp(self):
self.client = None
self.files = FileCreator()
# List of local filenames.
self.filenames = []
self.root = self.files.rootdir
self.bucket = 'bucket/'
filename_1 = self.files.create_file('foo.txt',
contents='foo.txt contents')
self.filenames.append(filename_1)
nested_dir = os.path.join(self.root, 'realfiles')
os.mkdir(nested_dir)
filename_2 = self.files.create_file(os.path.join(
nested_dir, 'bar.txt'),
contents='bar.txt contents')
self.filenames.append(filename_2)
# Names of symlinks.
self.symlinks = []
# Names of files if symlinks are followed.
self.symlink_files = []
# Create symlink to file foo.txt.
symlink_1 = os.path.join(self.root, 'symlink_1')
os.symlink(filename_1, symlink_1)
self.symlinks.append(symlink_1)
self.symlink_files.append(symlink_1)
# Create a symlink to a file that does not exist.
symlink_2 = os.path.join(self.root, 'symlink_2')
os.symlink('non-existent-file', symlink_2)
self.symlinks.append(symlink_2)
# Create a symlink to directory realfiles
symlink_3 = os.path.join(self.root, 'symlink_3')
os.symlink(nested_dir, symlink_3)
self.symlinks.append(symlink_3)
self.symlink_files.append(os.path.join(symlink_3, 'bar.txt'))
def setUp(self):
super(TestCodeArtifactLogin, self).setUp()
self.file_creator = FileCreator()
self.test_pypi_rc_path = self.file_creator.full_path('pypirc')
if not os.path.isdir(os.path.dirname(self.test_pypi_rc_path)):
os.makedirs(os.path.dirname(self.test_pypi_rc_path))
self.domain = 'domain'
self.domain_owner = 'domain-owner'
self.repository = 'repository'
self.auth_token = 'auth-token'
self.namespace = 'namespace'
self.duration = 3600
self.expiration = time.time() + self.duration
self.expiration_as_datetime = parse_timestamp(self.expiration)
self.pypi_rc_path_patch = mock.patch(
'awscli.customizations.codeartifact.login.TwineLogin'
'.get_pypi_rc_path'
)
self.pypi_rc_path_mock = self.pypi_rc_path_patch.start()
self.pypi_rc_path_mock.return_value = self.test_pypi_rc_path
self.subprocess_patch = mock.patch('subprocess.check_call')
self.subprocess_mock = self.subprocess_patch.start()
class TestStreamingOutput(BaseAWSCommandParamsTest):
def setUp(self):
super(TestStreamingOutput, self).setUp()
self.files = FileCreator()
def tearDown(self):
super(TestStreamingOutput, self).tearDown()
self.files.remove_all()
def test_get_media_streaming_output(self):
cmdline = ('kinesis-video-media get-media --stream-name test-stream '
'--start-selector StartSelectorType=EARLIEST %s')
self.parsed_response = {
'ContentType': 'video/webm',
'Payload': six.BytesIO(b'testbody')
}
outpath = self.files.full_path('outfile')
params = {
'StartSelector': {
'StartSelectorType': 'EARLIEST'
},
'StreamName': 'test-stream'
}
self.assert_params_for_cmd(cmdline % outpath, params)
with open(outpath, 'rb') as outfile:
self.assertEqual(outfile.read(), b'testbody')
def setUp(self):
super(TestCreateFunction, self).setUp()
# Make a temporary file
self.files = FileCreator()
self.contents_of_file = 'myzipcontents'
self.temp_file = self.files.create_file('foo', self.contents_of_file)
def setUp(self):
super(TestAddModel, self).setUp()
self.files = FileCreator()
self.customer_data_root = self.files.rootdir
self.data_loader = self.driver.session.get_component('data_loader')
self.data_loader.CUSTOMER_DATA_PATH = self.customer_data_root
self.service_definition = {
"version": "2.0",
"metadata": {
"apiVersion": '2015-12-02',
"endpointPrefix": 'myservice',
},
"operations": {},
"shapes": {}
}
self.service_unicode_definition = {
"version": "2.0",
"metadata": {
"apiVersion": '2015-12-02',
"endpointPrefix": 'myservice',
"keyWithUnicode": u'\u2713'
},
"operations": {},
"shapes": {}
}
def setUp(self):
self.session = mock.Mock(Session)
self.output_stream_factory = mock.Mock(OutputStreamFactory)
# MagicMock is needed because it can handle context managers.
# Normal Mock will throw AttributeErrors
output_stream_context = mock.MagicMock()
self.output_stream = mock.Mock()
output_stream_context.__enter__.return_value = self.output_stream
self.output_stream_factory.get_output_stream.return_value = \
output_stream_context
self.db_reader = mock.Mock(DatabaseRecordReader)
self.db_reader.iter_latest_records.return_value = []
self.db_reader.iter_records.return_value = []
self.show_cmd = ShowCommand(self.session, self.db_reader,
self.output_stream_factory)
self.formatter = mock.Mock(Formatter)
self.add_formatter('mock', self.formatter)
self.parsed_args = argparse.Namespace()
self.parsed_args.format = 'mock'
self.parsed_args.include = None
self.parsed_args.exclude = None
self.parsed_globals = argparse.Namespace()
self.parsed_globals.color = 'auto'
self.files = FileCreator()
def setUp(self):
self.file_creator = FileCreator()
self.test_pypi_rc_path = self.file_creator.full_path('pypirc')
if not os.path.isdir(os.path.dirname(self.test_pypi_rc_path)):
os.makedirs(os.path.dirname(self.test_pypi_rc_path))
self.domain = 'domain'
self.domain_owner = 'domain-owner'
self.repository = 'repository'
self.auth_token = 'auth-token'
self.namespace = 'namespace'
self.nuget_index_url_fmt = '{endpoint}v3/index.json'
self.nuget_source_name = self.domain + '/' + self.repository
self.duration = 3600
self.expiration = time.time() + self.duration
self.expiration_as_datetime = parse_timestamp(self.expiration)
self.pypi_rc_path_patch = mock.patch(
'awscli.customizations.codeartifact.login.TwineLogin'
'.get_pypi_rc_path')
self.pypi_rc_path_mock = self.pypi_rc_path_patch.start()
self.pypi_rc_path_mock.return_value = self.test_pypi_rc_path
self.subprocess_patch = mock.patch('subprocess.check_call')
self.subprocess_mock = self.subprocess_patch.start()
self.subprocess_check_output_patch = mock.patch(
'subprocess.check_output')
self.subprocess_check_out_mock = \
self.subprocess_check_output_patch.start()
self.cli_runner = CLIRunner()
class TestTopicTagDB(unittest.TestCase):
def setUp(self):
self.topic_tag_db = TopicTagDB()
self.file_creator = FileCreator()
def tearDown(self):
self.file_creator.remove_all()
class TestArgumentHelpers(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_only_validates_filename_when_set(self):
resolve_given_outfile_path(None)
def test_works_with_valid_filename(self):
filename = self.files.create_file("valid", "")
self.assertEquals(filename, resolve_given_outfile_path(filename))
def test_works_with_relative_filename(self):
filename = "../valid"
self.assertEquals(filename, resolve_given_outfile_path(filename))
def test_raises_when_cannot_write_to_file(self):
filename = os.sep.join(["_path", "not", "_exist_", "file.xyz"])
with self.assertRaises(ValueError):
resolve_given_outfile_path(filename)
def test_checks_if_valid_result(self):
result = {"ResponseMetadata": {"HTTPStatusCode": 200}}
self.assertTrue(is_parsed_result_successful(result))
def test_checks_if_invalid_result(self):
result = {"ResponseMetadata": {"HTTPStatusCode": 300}}
self.assertFalse(is_parsed_result_successful(result))
class BaseSSOTest(BaseAWSCommandParamsTest):
def setUp(self):
super(BaseSSOTest, self).setUp()
self.files = FileCreator()
self.start_url = 'https://mysigin.com'
self.sso_region = 'us-west-2'
self.account = '012345678912'
self.role_name = 'SSORole'
self.config_file = self.files.full_path('config')
self.environ['AWS_CONFIG_FILE'] = self.config_file
self.set_config_file_content()
self.access_token = 'foo.token.string'
def tearDown(self):
super(BaseSSOTest, self).tearDown()
self.files.remove_all()
def set_config_file_content(self, content=None):
if content is None:
content = ('[default]\n'
'sso_start_url=%s\n'
'sso_region=%s\n'
'sso_role_name=%s\n'
'sso_account_id=%s\n' %
(self.start_url, self.sso_region, self.role_name,
self.account))
self.files.create_file(self.config_file, content)
# We need to recreate the driver (which includes its session) in order
# for the config changes to be pulled in by the session.
self.driver = create_clidriver()
def setUp(self):
self.file_creator = FileCreator()
self.domain = 'domain'
self.domain_owner = 'domain-owner'
self.package_format = 'pip'
self.repository = 'repository'
self.auth_token = 'auth-token'
self.expiration = (datetime.now(tzlocal()) + relativedelta(years=1) +
relativedelta(months=9)).replace(microsecond=0)
self.endpoint = 'https://{domain}-{domainOwner}.codeartifact.aws.' \
'a2z.com/{format}/{repository}/'.format(
domain=self.domain,
domainOwner=self.domain_owner,
format=self.package_format,
repository=self.repository
)
self.default_pypi_rc = self.DEFAULT_PYPI_RC_FMT.format(
repository_endpoint=self.endpoint, auth_token=self.auth_token)
self.subprocess_utils = mock.Mock()
self.test_pypi_rc_path = self.file_creator.full_path('pypirc')
if not os.path.isdir(os.path.dirname(self.test_pypi_rc_path)):
os.makedirs(os.path.dirname(self.test_pypi_rc_path))
self.test_subject = TwineLogin(self.auth_token, self.expiration,
self.endpoint, self.subprocess_utils,
self.test_pypi_rc_path)
class TestSyncCommand(BaseAWSCommandParamsTest):
prefix = 's3 sync '
def setUp(self):
super(TestSyncCommand, self).setUp()
self.files = FileCreator()
def tearDown(self):
super(TestSyncCommand, self).tearDown()
self.files.remove_all()
def test_website_redirect_ignore_paramfile(self):
full_path = self.files.create_file('foo.txt', 'mycontent')
cmdline = '%s %s s3://bucket/key.txt --website-redirect %s' % \
(self.prefix, self.files.rootdir, 'http://someserver')
self.parsed_responses = [{
"CommonPrefixes": [],
"Contents": []
}, {
'ETag': '"c8afdb36c52cf4727836669019e69222"'
}]
self.run_cmd(cmdline, expected_rc=0)
# The only operations we should have called are ListObjects/PutObject.
self.assertEqual(len(self.operations_called), 2,
self.operations_called)
self.assertEqual(self.operations_called[0][0].name, 'ListObjects')
self.assertEqual(self.operations_called[1][0].name, 'PutObject')
# Make sure that the specified web address is used as opposed to the
# contents of the web address when uploading the object
self.assertEqual(
self.operations_called[1][1]['website_redirect_location'],
'http://someserver')
class TestAPIVersions(BaseAWSCommandParamsTest):
def setUp(self):
super(TestAPIVersions, self).setUp()
self.files = FileCreator()
# We just pick ec2 because it is a service that actually has
# multiple api versions.
self.service_name = 'ec2'
self.api_version = '2014-10-01'
config_contents = ('[default]\n'
'api_versions =\n'
' %s = %s\n' %
(self.service_name, self.api_version))
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'myconfig', config_contents)
self.driver = create_clidriver()
def tearDown(self):
super(TestAPIVersions, self).tearDown()
self.files.remove_all()
def test_command_send_correct_api_version(self):
cmdline = 'ec2 describe-instances'
self.run_cmd(cmdline)
# Make sure that the correct api version is used for the client
# by checking the version that was sent in the request.
self.assertEqual(self.last_params['Version'], self.api_version)
def test_command_interface_reflects_api_version(self):
# Take an arbitrary command such as describe-nat-gateways that is not
# in the 2014-10-01 EC2 API version and make sure its CLI command
# interface is not available as well.
cmdline = 'ec2 describe-nat-gateways'
_, stderr, _ = self.run_cmd(cmdline, expected_rc=2)
self.assertIn("Invalid choice: 'describe-nat-gateways'", stderr)
class TestTopicTagDB(unittest.TestCase):
def setUp(self):
self.topic_tag_db = TopicTagDB()
self.file_creator = FileCreator()
def tearDown(self):
self.file_creator.remove_all()
def setUp(self):
super(TestImortTerminology, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file(
'foo', 'mycontents')
with open(self.temp_file, 'rb') as f:
self.temp_file_contents = f.read()
class TestHelpCommandBase(unittest.TestCase):
def setUp(self):
self.session = mock.Mock()
self.file_creator = FileCreator()
def tearDown(self):
self.file_creator.remove_all()
class TestArgsResolution(BaseAWSCommandParamsTest):
def setUp(self):
super(TestArgsResolution, self).setUp()
self.files = FileCreator()
config_contents = (
'[profile bar]\n'
'region = us-west-2\n'
)
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'myconfig', config_contents)
self.driver = create_clidriver()
def tearDown(self):
super(TestArgsResolution, self).tearDown()
self.files.remove_all()
def test_profile_resolution_order(self):
self.environ['AWS_PROFILE'] = 'foo'
self.parsed_responses = [{"Reservations": []}]
self.run_cmd('--profile bar ec2 describe-instances', expected_rc=0)
self.assertEqual(self.driver.session.profile, 'bar')
def test_can_get_version_with_non_existent_profile(self):
self.environ['AWS_PROFILE'] = 'foo'
# ProfileNotFound exception shouldn't be raised
self.run_cmd('--version', expected_rc=0)
def setUp(self):
super(TestDeployCommand, self).setUp()
# setup required values
files = FileCreator()
self.task_def_file = files.create_file(
'taskDef.json', json.dumps(self.TASK_DEFINITION_JSON), mode='w')
self.appspec_file = files.create_file(
'appspec.yaml', self.YAML_APPSPEC, mode='w')
self.appspec_file_json = files.create_file(
'appspec.json', self.JSON_APPSPEC, mode='w')
self.service_name = 'serviceTest'
self.service_arn = 'arn:aws:ecs:::service/serviceTest'
# setup default optional values
self.cluster_name = 'default'
self.cluster_arn = 'arn:aws:ecs:::cluster/default'
self.application_name = get_app_name(
self.service_name, self.cluster_name, None)
self.deployment_group_name = get_deploy_group_name(
self.service_name, self.cluster_name, None)
# setup test response resources
self.missing_properties_appspec = files.create_file(
'appspec_bad.yaml', self.BAD_APPSPEC, mode='w')
self.task_definition_arn = \
'arn:aws:ecs::1234567890:task-definition\\test:2'
self.deployment_id = 'd-1234567XX'
self.mock_deployer = CodeDeployer(None, self.APPSPEC_DICT)
self.mock_deployer.update_task_def_arn(self.task_definition_arn)
self.expected_stdout = ("Successfully registered new ECS task "
"definition " + self.task_definition_arn + "\n"
"Successfully created deployment " +
self.deployment_id + "\n"
"Waiting for " + self.deployment_id +
" to succeed...\nSuccessfully deployed "
+ self.task_definition_arn + " to service '"
+ self.service_name + "'\n")
def test_make_zip(self):
test_file_creator = FileCreator()
test_file_creator.append_file('index.js',
'exports handler = (event, context, callback) => {callback(null, event);}')
dirname = test_file_creator.rootdir
expected_files = set(['index.js'])
random_name = ''.join(random.choice(string.ascii_letters) for _ in range(10))
outfile = os.path.join(tempfile.gettempdir(), random_name)
zipfile_name = None
try:
zipfile_name = make_zip(outfile, dirname)
test_zip_file = zipfile.ZipFile(zipfile_name, "r")
with closing(test_zip_file) as zf:
files_in_zip = set()
for info in zf.infolist():
files_in_zip.add(info.filename)
self.assertEquals(files_in_zip, expected_files)
finally:
if zipfile_name:
os.remove(zipfile_name)
test_file_creator.remove_all()
class TestHelpCommandBase(unittest.TestCase):
def setUp(self):
self.session = mock.Mock()
self.file_creator = FileCreator()
def tearDown(self):
self.file_creator.remove_all()
class TestArgumentHelpers(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_only_validates_filename_when_set(self):
resolve_given_outfile_path(None)
def test_works_with_valid_filename(self):
filename = self.files.create_file('valid', '')
self.assertEqual(filename, resolve_given_outfile_path(filename))
def test_works_with_relative_filename(self):
filename = '../valid'
self.assertEqual(filename, resolve_given_outfile_path(filename))
def test_raises_when_cannot_write_to_file(self):
filename = os.sep.join(['_path', 'not', '_exist_', 'file.xyz'])
with self.assertRaises(ValueError):
resolve_given_outfile_path(filename)
def test_checks_if_valid_result(self):
result = {'ResponseMetadata': {'HTTPStatusCode': 200}}
self.assertTrue(is_parsed_result_successful(result))
def test_checks_if_invalid_result(self):
result = {'ResponseMetadata': {'HTTPStatusCode': 300}}
self.assertFalse(is_parsed_result_successful(result))
class TestStreamingOutput(BaseAWSCommandParamsTest):
def setUp(self):
super(TestStreamingOutput, self).setUp()
self.files = FileCreator()
def tearDown(self):
super(TestStreamingOutput, self).tearDown()
self.files.remove_all()
def test_get_media_streaming_output(self):
cmdline = (
'kinesis-video-media get-media --stream-name test-stream '
'--start-selector StartSelectorType=EARLIEST %s'
)
self.parsed_response = {
'ContentType': 'video/webm',
'Payload': six.BytesIO(b'testbody')
}
outpath = self.files.full_path('outfile')
params = {
'StartSelector': {'StartSelectorType': 'EARLIEST'},
'StreamName': 'test-stream'
}
self.assert_params_for_cmd(cmdline % outpath, params)
with open(outpath, 'rb') as outfile:
self.assertEqual(outfile.read(), b'testbody')
class TestAPIVersions(BaseAWSCommandParamsTest):
def setUp(self):
super(TestAPIVersions, self).setUp()
self.files = FileCreator()
# We just pick ec2 because it is a service that actually has
# multiple api versions.
self.service_name = 'ec2'
self.api_version = '2014-10-01'
config_contents = (
'[default]\n'
'api_versions =\n'
' %s = %s\n' % (self.service_name, self.api_version)
)
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'myconfig', config_contents)
self.driver = create_clidriver()
def tearDown(self):
super(TestAPIVersions, self).tearDown()
self.files.remove_all()
def test_command_send_correct_api_version(self):
cmdline = 'ec2 describe-instances'
self.run_cmd(cmdline)
# Make sure that the correct api version is used for the client
# by checking the version that was sent in the request.
self.assertEqual(self.last_params['Version'], self.api_version)
def test_command_interface_reflects_api_version(self):
# Take an arbitrary command such as describe-nat-gateways that is not
# in the 2014-10-01 EC2 API version and make sure its CLI command
# interface is not available as well.
cmdline = 'ec2 describe-nat-gateways'
_, stderr, _ = self.run_cmd(cmdline, expected_rc=2)
self.assertIn("Invalid choice: 'describe-nat-gateways'", stderr)
class TestGetGameSessionLogCommand(unittest.TestCase):
def setUp(self):
self.create_client_patch = mock.patch(
'botocore.session.Session.create_client')
self.mock_create_client = self.create_client_patch.start()
self.session = get_session()
self.client = mock.Mock()
self.mock_create_client.return_value = self.client
self.cmd = GetGameSessionLogCommand(self.session)
self.contents = b'mycontents'
self.file_creator = FileCreator()
self.urlopen_patch = mock.patch(
'awscli.customizations.gamelift.getlog.urlopen')
self.urlopen_mock = self.urlopen_patch.start()
self.urlopen_mock.return_value = six.BytesIO(self.contents)
def tearDown(self):
self.create_client_patch.stop()
self.file_creator.remove_all()
self.urlopen_patch.stop()
def test_get_game_session_log(self):
session_id = 'mysessionid'
save_as = os.path.join(self.file_creator.rootdir, 'mylog')
args = ['--game-session-id', session_id, '--save-as', save_as]
global_args = Namespace()
global_args.region = 'us-west-2'
global_args.endpoint_url = None
global_args.verify_ssl = None
presigned_url = 'mypresignedurl'
self.client.get_game_session_log_url.return_value = {
'PreSignedUrl': presigned_url
}
# Call the command
self.cmd(args, global_args)
# Ensure the client was created properly
self.mock_create_client.assert_called_once_with(
'gamelift',
region_name='us-west-2',
endpoint_url=None,
verify=None)
# Ensure the client was called correctly
self.client.get_game_session_log_url.assert_called_once_with(
GameSessionId=session_id)
# Ensure the presigned url was used
self.urlopen_mock.assert_called_once_with(presigned_url)
# Ensure the contents were saved to the file
with open(save_as, 'rb') as f:
self.assertEqual(f.read(), self.contents)
class BaseCLIInputArgumentTest(BaseAWSCommandParamsTest):
def setUp(self):
super(BaseCLIInputArgumentTest, self).setUp()
self.files = FileCreator()
def tearDown(self):
super(BaseCLIInputArgumentTest, self).tearDown()
self.files.remove_all()
class BaseHistoryCommandParamsTest(BaseAWSCommandParamsTest):
def setUp(self):
history_recorder = self._make_clean_history_recorder()
super(BaseHistoryCommandParamsTest, self).setUp()
self.history_recorder = history_recorder
self.files = FileCreator()
config_contents = ('[default]\n' 'cli_history = enabled')
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'config', config_contents)
self.environ['AWS_CLI_HISTORY_FILE'] = self.files.create_file(
'history.db', '')
self.driver = create_clidriver()
# The run_cmd patches stdout with a StringIO object (similar to what
# nose does). Therefore it will run into issues when
# get_binary_stdout is called because it returns sys.stdout.buffer
# for Py3 and StringIO does not have a buffer
self.binary_stdout_patch = mock.patch('awscli.utils.get_binary_stdout')
mock_get_binary_stdout = self.binary_stdout_patch.start()
self.binary_stdout = BytesIO()
mock_get_binary_stdout.return_value = self.binary_stdout
def _make_clean_history_recorder(self):
# This is to ensure that for each new test run the CLI is using
# a brand new HistoryRecorder as this is global so previous test
# runs could have injected handlers onto it as all of the tests
# are ran in the same process.
history_recorder = HistoryRecorder()
# The HISTORY_RECORDER is instantiated on module import before we
# doing any patching which means we cannot simply patch
# botocore.get_global_history_recorder as the objects are already
# instantiated as so we have to individually patch each one of these...
self._apply_history_recorder_patch('awscli.clidriver',
history_recorder)
self._apply_history_recorder_patch('awscli.customizations.history',
history_recorder)
return history_recorder
def _apply_history_recorder_patch(self, module, history_recorder):
patch_history_recorder = mock.patch(module + '.HISTORY_RECORDER',
history_recorder)
patch_history_recorder.start()
self.addCleanup(patch_history_recorder.stop)
def _cleanup_db_connections(self):
# Reaching into private data to close out the database connection.
# Windows won't let us delete the tempdir until these connections are
# closed in the tearDown step and we have no other way of forcing
# them to close.
handlers = self.history_recorder._handlers
for handler in handlers:
handler._writer.close()
def tearDown(self):
super(BaseHistoryCommandParamsTest, self).tearDown()
self._cleanup_db_connections()
self.files.remove_all()
self.binary_stdout_patch.stop()
class TestShow(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
self.environ = os.environ.copy()
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'config', ('[default]\n'
'cli_history = enabled'))
self.environ['AWS_DEFAULT_PROFILE'] = 'default'
self.environ['AWS_DEFAULT_REGION'] = 'us-west-2'
self.environ['AWS_CLI_HISTORY_FILE'] = os.path.join(
self.files.rootdir, 'history.db')
def tearDown(self):
self.files.remove_all()
def remove_color(self, output):
return re.compile(r'\x1b[^m]*m').sub('', output)
def assert_contains_in_order(self, lines, contents):
current_pos = 0
prev_line = None
for line in lines:
self.assertIn(line, contents)
new_pos = contents.find(line)
if new_pos < current_pos:
self.fail('Line: "%s" should have came after line: "%s"' %
(line, prev_line))
prev_line = line
current_pos = new_pos
def test_show(self):
# Make a call that does not require credentials just in case the
# user was using the config file to provide credentials.
cmd = 'sts assume-role-with-saml '
cmd += '--role-arn arn:aws:iam::...:invalid '
cmd += '--principal-arn arn:aws:iam::...:invalid '
cmd += '--saml-assertion fake-assertion'
aws(cmd, env_vars=self.environ)
# Now run the show command and make sure the general output is all
# there.
result = aws('history show', env_vars=self.environ)
uncolored_content = self.remove_color(result.stdout)
self.assert_contains_in_order([
'AWS CLI command entered', 'with AWS CLI version: aws-cli/',
"with arguments: ['sts', 'assume-role-with-saml',",
'[0] API call made', 'to service: sts',
'using operation: AssumeRoleWithSAML', 'with parameters: {',
' "PrincipalArn": "arn:aws:iam::...:invalid",',
' "RoleArn": "arn:aws:iam::...:invalid",',
' "SAMLAssertion": "fake-assertion"', '[0] HTTP request sent',
'to URL: https://sts.amazonaws.com/', 'with method: POST',
'with body: Action=AssumeRoleWithSAML&Version=2011-06-15',
'[0] HTTP response received', 'with status code: 400',
'with body: <?xml version="1.0" ?>', '[0] HTTP response parsed',
'parsed to: {', ' "Error": {', 'AWS CLI command exited',
'with return code: 255'
], uncolored_content)
class TestQueryFileArgument(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_proxies_to_super_ctor(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "bar.baz", "event", 0o600)
self.assertEqual("foo", arg.name)
self.assertEqual("bar.baz", arg.query)
def test_adds_default_help_text(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "bar.baz", "event", 0o600)
self.assertEqual(("Saves the command output contents of bar.baz " "to the given filename"), arg.documentation)
def test_does_not_add_help_text_if_set(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "bar.baz", "event", 0o600, help_text="abc")
self.assertEqual("abc", arg.documentation)
def test_saves_query_to_file(self):
outfile = self.files.create_file("not-empty-test", "")
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "baz", "event", 0o600)
arg.add_to_params({}, outfile)
arg.save_query({"ResponseMetadata": {"HTTPStatusCode": 200}, "baz": "abc123"})
with open(outfile) as fp:
self.assertEquals("abc123", fp.read())
self.assertEquals(1, session.register.call_count)
session.register.assert_called_with("event", arg.save_query)
def test_does_not_save_when_not_set(self):
session = mock.Mock()
QueryOutFileArgument(session, "foo", "baz", "event", 0o600)
self.assertEquals(0, session.register.call_count)
def test_saves_query_to_file_as_empty_string_when_none_result(self):
outfile = self.files.create_file("none-test", "")
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "baz", "event", 0o600)
arg.add_to_params({}, outfile)
arg.save_query({"ResponseMetadata": {"HTTPStatusCode": 200}})
with open(outfile) as fp:
self.assertEquals("", fp.read())
@skip_if_windows("Test not valid on windows.")
def test_permissions_on_created_file(self):
outfile = self.files.create_file("not-empty-test", "")
session = mock.Mock()
arg = QueryOutFileArgument(session, "foo", "baz", "event", 0o600)
arg.add_to_params({}, outfile)
arg.save_query({"ResponseMetadata": {"HTTPStatusCode": 200}, "baz": "abc123"})
with open(outfile) as fp:
fp.read()
self.assertEqual(os.stat(outfile).st_mode & 0xFFF, 0o600)
def setUp(self):
super(TestPlugins, self).setUp()
self.files = FileCreator()
self.plugins_site_packages = os.path.join(self.files.rootdir,
'site-packages')
self.plugin_module_name = 'add_awscli_cmd_plugin'
self.plugin_filename = os.path.join(os.path.dirname(__file__),
self.plugin_module_name) + '.py'
self.setup_plugin_site_packages()
class TestQueryFileArgument(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_proxies_to_super_ctor(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'bar.baz', 'event')
self.assertEqual('foo', arg.name)
self.assertEqual('bar.baz', arg.query)
def test_adds_default_help_text(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'bar.baz', 'event')
self.assertEqual(('Saves the command output contents of bar.baz '
'to the given filename'), arg.documentation)
def test_does_not_add_help_text_if_set(self):
session = mock.Mock()
arg = QueryOutFileArgument(session,
'foo',
'bar.baz',
'event',
help_text='abc')
self.assertEqual('abc', arg.documentation)
def test_saves_query_to_file(self):
outfile = self.files.create_file('not-empty-test', '')
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'baz', 'event')
arg.add_to_params({}, outfile)
arg.save_query({
'ResponseMetadata': {
'HTTPStatusCode': 200
},
'baz': 'abc123'
})
with open(outfile) as fp:
self.assertEquals('abc123', fp.read())
self.assertEquals(1, session.register.call_count)
session.register.assert_called_with('event', arg.save_query)
def test_does_not_save_when_not_set(self):
session = mock.Mock()
QueryOutFileArgument(session, 'foo', 'baz', 'event')
self.assertEquals(0, session.register.call_count)
def test_saves_query_to_file_as_empty_string_when_none_result(self):
outfile = self.files.create_file('none-test', '')
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'baz', 'event')
arg.add_to_params({}, outfile)
arg.save_query({'ResponseMetadata': {'HTTPStatusCode': 200}})
with open(outfile) as fp:
self.assertEquals('', fp.read())
def setUp(self):
super(BaseLambdaTests, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file('foo', 'mycontents')
self.zip_file = os.path.join(self.files.rootdir, 'foo.zip')
with closing(zipfile.ZipFile(self.zip_file, 'w')) as f:
f.write(self.temp_file)
with open(self.zip_file, 'rb') as f:
self.zip_file_contents = f.read()
def setUp(self):
super(TestGetGameSessionLog, self).setUp()
self.files = FileCreator()
self.filename = os.path.join(self.files.rootdir, 'myfile')
self.urlopen_patch = mock.patch(
'awscli.customizations.gamelift.getlog.urlopen')
self.contents = b'My Contents'
self.urlopen_mock = self.urlopen_patch.start()
self.urlopen_mock.return_value = six.BytesIO(self.contents)
class TestAliasCommandInjector(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
self.alias_file = self.files.create_file("alias", "[toplevel]\n")
self.alias_loader = AliasLoader(self.alias_file)
self.session = mock.Mock(spec=Session)
self.alias_cmd_injector = AliasCommandInjector(self.session, self.alias_loader)
self.command_table = {}
self.parser = MainArgParser(
command_table=self.command_table, version_string="version", description="description", argument_table={}
)
def tearDown(self):
self.files.remove_all()
def test_service_alias_command(self):
with open(self.alias_file, "a+") as f:
f.write("my-alias = my-alias-value\n")
self.alias_cmd_injector.inject_aliases(self.command_table, self.parser)
self.assertIn("my-alias", self.command_table)
self.assertIsInstance(self.command_table["my-alias"], ServiceAliasCommand)
def test_external_alias_command(self):
with open(self.alias_file, "a+") as f:
f.write("my-alias = !my-alias-value\n")
self.alias_cmd_injector.inject_aliases(self.command_table, self.parser)
self.assertIn("my-alias", self.command_table)
self.assertIsInstance(self.command_table["my-alias"], ExternalAliasCommand)
def test_clobbers_builtins(self):
builtin_cmd = mock.Mock(spec=CLICommand)
self.command_table["builtin"] = builtin_cmd
with open(self.alias_file, "a+") as f:
f.write("builtin = my-alias-value\n")
self.alias_cmd_injector.inject_aliases(self.command_table, self.parser)
self.assertIn("builtin", self.command_table)
self.assertIsInstance(self.command_table["builtin"], ServiceAliasCommand)
def test_shadow_proxy_command(self):
builtin_cmd = mock.Mock(spec=CLICommand)
builtin_cmd.name = "builtin"
self.command_table["builtin"] = builtin_cmd
with open(self.alias_file, "a+") as f:
f.write("builtin = builtin\n")
self.alias_cmd_injector.inject_aliases(self.command_table, self.parser)
self.command_table["builtin"]([], FakeParsedArgs(command="builtin"))
# The builtin command should be passed to the alias
# command when added to the table.
builtin_cmd.assert_called_with([], FakeParsedArgs(command="builtin"))
def setUp(self):
super(TestCLITimestampParser, self).setUp()
self.files = FileCreator()
self.wire_response = json.dumps({
'builds': [{
'startTime': 0,
}]
}).encode('utf-8')
self.command = ['codebuild', 'batch-get-builds', '--ids', 'foo']
self.patch_send(content=self.wire_response)
def setUp(self):
self.files = FileCreator()
self.environ = os.environ.copy()
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'config', ('[default]\n'
'cli_history = enabled'))
self.environ['AWS_DEFAULT_PROFILE'] = 'default'
self.environ['AWS_DEFAULT_REGION'] = 'us-west-2'
self.environ['AWS_CLI_HISTORY_FILE'] = os.path.join(
self.files.rootdir, 'history.db')
def setUp(self):
super(TestArgsResolution, self).setUp()
self.files = FileCreator()
config_contents = (
'[profile bar]\n'
'region = us-west-2\n'
)
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'myconfig', config_contents)
self.driver = create_clidriver()
class TestIgnoreFilesLocally(unittest.TestCase):
"""
This class tests the ability to ignore particular files. This includes
skipping symlink when desired.
"""
def setUp(self):
self.session = FakeSession()
self.service = self.session.get_service('s3')
self.endpoint = self.service.get_endpoint('us-east-1')
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_bad_symlink(self):
path = os.path.join(self.files.rootdir, 'badsymlink')
os.symlink('non-existent-file', path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertFalse(filegenerator.should_ignore_file(path))
def test_skip_symlink(self):
filename = 'foo.txt'
self.files.create_file(os.path.join(self.files.rootdir,
filename),
contents='foo.txt contents')
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(filename, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', False)
self.assertTrue(filegenerator.should_ignore_file(sym_path))
def test_no_skip_symlink(self):
filename = 'foo.txt'
path = self.files.create_file(os.path.join(self.files.rootdir,
filename),
contents='foo.txt contents')
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(path, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertFalse(filegenerator.should_ignore_file(sym_path))
self.assertFalse(filegenerator.should_ignore_file(path))
def test_no_skip_symlink_dir(self):
filename = 'dir'
path = os.path.join(self.files.rootdir, 'dir/')
os.mkdir(path)
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(path, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertFalse(filegenerator.should_ignore_file(sym_path))
self.assertFalse(filegenerator.should_ignore_file(path))
def setUp(self):
super(BaseSSOTest, self).setUp()
self.files = FileCreator()
self.start_url = 'https://mysigin.com'
self.sso_region = 'us-west-2'
self.account = '012345678912'
self.role_name = 'SSORole'
self.config_file = self.files.full_path('config')
self.environ['AWS_CONFIG_FILE'] = self.config_file
self.set_config_file_content()
self.access_token = 'foo.token.string'
class TestPlugins(BaseCLIDriverTest):
def setUp(self):
super(TestPlugins, self).setUp()
self.files = FileCreator()
self.plugins_site_packages = os.path.join(self.files.rootdir,
'site-packages')
self.plugin_module_name = 'add_awscli_cmd_plugin'
self.plugin_filename = os.path.join(os.path.dirname(__file__),
self.plugin_module_name) + '.py'
self.setup_plugin_site_packages()
def setup_plugin_site_packages(self):
os.makedirs(self.plugins_site_packages)
shutil.copy(self.plugin_filename, self.plugins_site_packages)
def tearDown(self):
super(TestPlugins, self).tearDown()
self.files.remove_all()
def assert_plugin_loaded(self, clidriver):
self.assertIn('plugin-test-cmd', clidriver.subcommand_table)
def assert_plugin_not_loaded(self, clidriver):
self.assertNotIn('plugin-test-cmd', clidriver.subcommand_table)
def create_config(self, config_contents):
config_file = self.files.create_file('config', config_contents)
self.environ['AWS_CONFIG_FILE'] = config_file
def test_plugins_loaded_from_specified_path(self):
self.create_config(
'[plugins]\n'
'cli_legacy_plugin_path = %s\n'
'myplugin = %s\n' %
(self.plugins_site_packages, self.plugin_module_name))
clidriver = create_clidriver()
self.assert_plugin_loaded(clidriver)
def test_plugins_are_not_loaded_when_path_specified(self):
self.create_config('[plugins]\n'
'myplugin = %s\n' % self.plugin_module_name)
clidriver = create_clidriver()
self.assert_plugin_not_loaded(clidriver)
def test_looks_in_all_specified_paths(self):
nonexistent_dir = os.path.join(self.files.rootdir, 'no-exist')
plugin_path = os.pathsep.join(
[nonexistent_dir, self.plugins_site_packages])
self.create_config('[plugins]\n'
'cli_legacy_plugin_path = %s\n'
'myplugin = %s\n' %
(plugin_path, self.plugin_module_name))
clidriver = create_clidriver()
self.assert_plugin_loaded(clidriver)
class TestIgnoreFilesLocally(unittest.TestCase):
"""
This class tests the ability to ignore particular files. This includes
skipping symlink when desired.
"""
def setUp(self):
self.session = FakeSession()
self.service = self.session.get_service('s3')
self.endpoint = self.service.get_endpoint('us-east-1')
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_warning(self):
path = os.path.join(self.files.rootdir, 'badsymlink')
os.symlink('non-existent-file', path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertTrue(filegenerator.should_ignore_file(path))
def test_skip_symlink(self):
filename = 'foo.txt'
self.files.create_file(os.path.join(self.files.rootdir,
filename),
contents='foo.txt contents')
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(filename, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', False)
self.assertTrue(filegenerator.should_ignore_file(sym_path))
def test_no_skip_symlink(self):
filename = 'foo.txt'
path = self.files.create_file(os.path.join(self.files.rootdir,
filename),
contents='foo.txt contents')
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(path, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertFalse(filegenerator.should_ignore_file(sym_path))
self.assertFalse(filegenerator.should_ignore_file(path))
def test_no_skip_symlink_dir(self):
filename = 'dir'
path = os.path.join(self.files.rootdir, 'dir/')
os.mkdir(path)
sym_path = os.path.join(self.files.rootdir, 'symlink')
os.symlink(path, sym_path)
filegenerator = FileGenerator(self.service, self.endpoint,
'', True)
self.assertFalse(filegenerator.should_ignore_file(sym_path))
self.assertFalse(filegenerator.should_ignore_file(path))
class BaseRekognitionTest(BaseAWSCommandParamsTest):
def setUp(self):
super(BaseRekognitionTest, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file(
'foo', 'mycontents')
with open(self.temp_file, 'rb') as f:
self.temp_file_bytes = f.read()
def tearDown(self):
super(BaseRekognitionTest, self).tearDown()
self.files.remove_all()
class TestGetGameSessionLogCommand(unittest.TestCase):
def setUp(self):
self.create_client_patch = mock.patch("botocore.session.Session.create_client")
self.mock_create_client = self.create_client_patch.start()
self.session = get_session()
self.client = mock.Mock()
self.mock_create_client.return_value = self.client
self.cmd = GetGameSessionLogCommand(self.session)
self.contents = b"mycontents"
self.file_creator = FileCreator()
self.urlopen_patch = mock.patch("awscli.customizations.gamelift.getlog.urlopen")
self.urlopen_mock = self.urlopen_patch.start()
self.urlopen_mock.return_value = six.BytesIO(self.contents)
def tearDown(self):
self.create_client_patch.stop()
self.file_creator.remove_all()
self.urlopen_patch.stop()
def test_get_game_session_log(self):
session_id = "mysessionid"
save_as = os.path.join(self.file_creator.rootdir, "mylog")
args = ["--game-session-id", session_id, "--save-as", save_as]
global_args = Namespace()
global_args.region = "us-west-2"
global_args.endpoint_url = None
global_args.verify_ssl = None
presigned_url = "mypresignedurl"
self.client.get_game_session_log_url.return_value = {"PreSignedUrl": presigned_url}
# Call the command
self.cmd(args, global_args)
# Ensure the client was created properly
self.mock_create_client.assert_called_once_with(
"gamelift", region_name="us-west-2", endpoint_url=None, verify=None
)
# Ensure the client was called correctly
self.client.get_game_session_log_url.assert_called_once_with(GameSessionId=session_id)
# Ensure the presigned url was used
self.urlopen_mock.assert_called_once_with(presigned_url)
# Ensure the contents were saved to the file
with open(save_as, "rb") as f:
self.assertEqual(f.read(), self.contents)
class TestCreateFunction(BaseAWSCommandParamsTest):
prefix = 'lambda create-function'
def setUp(self):
super(TestCreateFunction, self).setUp()
# Make a temporary file
self.files = FileCreator()
self.contents_of_file = 'myzipcontents'
self.temp_file = self.files.create_file(
'foo', self.contents_of_file)
def tearDown(self):
super(TestCreateFunction, self).tearDown()
self.files.remove_all()
def test_create_function(self):
cmdline = self.prefix
cmdline += ' --function-name myfunction --runtime myruntime'
cmdline += ' --role myrole --handler myhandler --zip-file myzip'
result = {
'FunctionName': 'myfunction',
'Runtime': 'myruntime',
'Role': 'myrole',
'Handler': 'myhandler',
'Code': {'ZipFile': 'myzip'}
}
self.assert_params_for_cmd(cmdline, result)
def test_create_function_with_file(self):
cmdline = self.prefix
cmdline += ' --function-name myfunction --runtime myruntime'
cmdline += ' --role myrole --handler myhandler'
cmdline += ' --zip-file file://%s' % self.temp_file
result = {
'FunctionName': 'myfunction',
'Runtime': 'myruntime',
'Role': 'myrole',
'Handler': 'myhandler',
'Code': {'ZipFile': self.contents_of_file}
}
self.assert_params_for_cmd(cmdline, result)
def test_create_function_code_argument_cause_error(self):
cmdline = self.prefix
cmdline += ' --function-name myfunction --runtime myruntime'
cmdline += ' --role myrole --handler myhandler --zip-file myzip'
cmdline += ' --code mycode'
stdout, stderr, rc = self.run_cmd(cmdline, expected_rc=255)
self.assertIn('Unknown options: --code', stderr)
class BaseLambdaTests(BaseAWSCommandParamsTest):
def setUp(self):
super(BaseLambdaTests, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file("foo", "mycontents")
self.zip_file = os.path.join(self.files.rootdir, "foo.zip")
with closing(zipfile.ZipFile(self.zip_file, "w")) as f:
f.write(self.temp_file)
with open(self.zip_file, "rb") as f:
self.zip_file_contents = f.read()
def tearDown(self):
super(BaseLambdaTests, self).tearDown()
self.files.remove_all()
class TestQueryFileArgument(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def test_proxies_to_super_ctor(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'bar.baz', 'event')
self.assertEqual('foo', arg.name)
self.assertEqual('bar.baz', arg.query)
def test_adds_default_help_text(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'bar.baz', 'event')
self.assertEqual(('Saves the command output contents of bar.baz '
'to the given filename'), arg.documentation)
def test_does_not_add_help_text_if_set(self):
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'bar.baz', 'event',
help_text='abc')
self.assertEqual('abc', arg.documentation)
def test_saves_query_to_file(self):
outfile = self.files.create_file('not-empty-test', '')
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'baz', 'event')
arg.add_to_params({}, outfile)
arg.save_query({'ResponseMetadata': {'HTTPStatusCode': 200},
'baz': 'abc123'})
with open(outfile) as fp:
self.assertEquals('abc123', fp.read())
self.assertEquals(1, session.register.call_count)
session.register.assert_called_with('event', arg.save_query)
def test_does_not_save_when_not_set(self):
session = mock.Mock()
QueryOutFileArgument(session, 'foo', 'baz', 'event')
self.assertEquals(0, session.register.call_count)
def test_saves_query_to_file_as_empty_string_when_none_result(self):
outfile = self.files.create_file('none-test', '')
session = mock.Mock()
arg = QueryOutFileArgument(session, 'foo', 'baz', 'event')
arg.add_to_params({}, outfile)
arg.save_query({'ResponseMetadata': {'HTTPStatusCode': 200}})
with open(outfile) as fp:
self.assertEquals('', fp.read())
class TestCLITimestampParser(BaseCLIWireResponseTest):
def setUp(self):
super(TestCLITimestampParser, self).setUp()
self.files = FileCreator()
self.wire_response = json.dumps({
'builds': [{
'startTime': 0,
}]
}).encode('utf-8')
self.command = ['codebuild', 'batch-get-builds', '--ids', 'foo']
self.patch_send(content=self.wire_response)
def tearDown(self):
super(TestCLITimestampParser, self).tearDown()
self.files.remove_all()
def test_iso(self):
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'iso',
'[default]\ncli_timestamp_format = iso8601\n')
self.driver = create_clidriver()
expected_time = datetime.datetime.fromtimestamp(0).replace(
tzinfo=tzlocal()).isoformat()
stdout, _, _ = self.run_cmd(self.command)
json_response = json.loads(stdout)
start_time = json_response["builds"][0]["startTime"]
self.assertEqual(expected_time, start_time)
def test_none(self):
self.environ['AWS_CONFIG_FILE'] = self.files.create_file(
'none',
'[default]\ncli_timestamp_format = none\n')
self.driver = create_clidriver()
expected_time = 0
stdout, _, _ = self.run_cmd(self.command)
json_response = json.loads(stdout)
start_time = json_response["builds"][0]["startTime"]
self.assertEqual(expected_time, start_time)
def test_default(self):
self.driver = create_clidriver()
expected_time = 0
stdout, _, _ = self.run_cmd(self.command)
json_response = json.loads(stdout)
start_time = json_response["builds"][0]["startTime"]
self.assertEqual(expected_time, start_time)
def setUp(self):
super(BaseRekognitionTest, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file(
'foo', 'mycontents')
with open(self.temp_file, 'rb') as f:
self.temp_file_bytes = f.read()
def setUp(self):
super(TestAddModel, self).setUp()
self.files = FileCreator()
self.customer_data_root = self.files.rootdir
self.data_loader = self.driver.session.get_component('data_loader')
self.data_loader.CUSTOMER_DATA_PATH = self.customer_data_root
self.service_definition = {
"version": "2.0",
"metadata": {
"apiVersion": '2015-12-02',
"endpointPrefix": 'myservice',
},
"operations": {},
"shapes": {}
}
self.service_unicode_definition = {
"version": "2.0",
"metadata": {
"apiVersion": '2015-12-02',
"endpointPrefix": 'myservice',
"keyWithUnicode": u'\u2713'
},
"operations": {},
"shapes": {}
}
class BaseS3TransferCommandTest(BaseAWSCommandParamsTest):
def setUp(self):
super(BaseS3TransferCommandTest, self).setUp()
self.files = FileCreator()
def tearDown(self):
super(BaseS3TransferCommandTest, self).tearDown()
self.files.remove_all()
def assert_operations_called(self, expected_operations_with_params):
actual_operations_with_params = [
(operation_called[0].name, operation_called[1])
for operation_called in self.operations_called
]
self.assertEqual(
actual_operations_with_params, expected_operations_with_params)
def setUp(self):
self.client = None
self.files = FileCreator()
# List of local filenames.
self.filenames = []
self.root = self.files.rootdir
self.bucket = 'bucket/'
filename_1 = self.files.create_file('foo.txt',
contents='foo.txt contents')
self.filenames.append(filename_1)
nested_dir = os.path.join(self.root, 'realfiles')
os.mkdir(nested_dir)
filename_2 = self.files.create_file(os.path.join(nested_dir,
'bar.txt'),
contents='bar.txt contents')
self.filenames.append(filename_2)
# Names of symlinks.
self.symlinks = []
# Names of files if symlinks are followed.
self.symlink_files = []
# Create symlink to file foo.txt.
symlink_1 = os.path.join(self.root, 'symlink_1')
os.symlink(filename_1, symlink_1)
self.symlinks.append(symlink_1)
self.symlink_files.append(symlink_1)
# Create a symlink to a file that does not exist.
symlink_2 = os.path.join(self.root, 'symlink_2')
os.symlink('non-existent-file', symlink_2)
self.symlinks.append(symlink_2)
# Create a symlink to directory realfiles
symlink_3 = os.path.join(self.root, 'symlink_3')
os.symlink(nested_dir, symlink_3)
self.symlinks.append(symlink_3)
self.symlink_files.append(os.path.join(symlink_3, 'bar.txt'))
def setUp(self):
super(TestCreateFunction, self).setUp()
# Make a temporary file
self.files = FileCreator()
self.contents_of_file = 'myzipcontents'
self.temp_file = self.files.create_file(
'foo', self.contents_of_file)
class TestAddModel(BaseAWSCommandParamsTest):
prefix = 'configure add-model'
def setUp(self):
super(TestAddModel, self).setUp()
self.files = FileCreator()
self.customer_data_root = self.files.rootdir
self.data_loader = self.driver.session.get_component('data_loader')
self.data_loader.CUSTOMER_DATA_PATH = self.customer_data_root
self.service_definition = {
"version": "2.0",
"metadata": {
"apiVersion": '2015-12-02',
"endpointPrefix": 'myservice',
},
"operations": {},
"shapes": {}
}
def tearDown(self):
super(TestAddModel, self).tearDown()
self.files.remove_all()
def test_add_model(self):
cmdline = self.prefix + ' --service-model %s' % json.dumps(
self.service_definition, separators=(',', ':'))
self.run_cmd(cmdline)
# Ensure that the model exists in the correct location.
self.assertTrue(
os.path.exists(os.path.join(
self.customer_data_root, 'myservice', '2015-12-02',
'service-2.json')))
def test_add_model_with_service_name(self):
cmdline = self.prefix + ' --service-model %s' % json.dumps(
self.service_definition, separators=(',', ':'))
cmdline += ' --service-name override-name'
self.run_cmd(cmdline)
# Ensure that the model exists in the correct location.
self.assertTrue(
os.path.exists(os.path.join(
self.customer_data_root, 'override-name', '2015-12-02',
'service-2.json')))
class TestGetGameSessionLog(BaseAWSCommandParamsTest):
prefix = 'gamelift get-game-session-log'
def setUp(self):
super(TestGetGameSessionLog, self).setUp()
self.files = FileCreator()
self.filename = os.path.join(self.files.rootdir, 'myfile')
self.urlopen_patch = mock.patch(
'awscli.customizations.gamelift.getlog.urlopen')
self.contents = b'My Contents'
self.urlopen_mock = self.urlopen_patch.start()
self.urlopen_mock.return_value = six.BytesIO(self.contents)
def tearDown(self):
super(TestGetGameSessionLog, self).tearDown()
self.files.remove_all()
self.urlopen_patch.stop()
def test_get_game_session_log(self):
cmdline = self.prefix
cmdline += ' --game-session-id mysession'
cmdline += ' --save-as %s' % self.filename
self.parsed_responses = [{'PreSignedUrl': 'myurl'}]
stdout, stderr, rc = self.run_cmd(cmdline, expected_rc=0)
self.assertEqual(len(self.operations_called), 1)
self.assertEqual(
self.operations_called[0][0].name, 'GetGameSessionLogUrl')
self.assertEqual(
self.operations_called[0][1],
{'GameSessionId': 'mysession'}
)
# Ensure the contents were saved to the file
self.assertTrue(os.path.exists(self.filename))
with open(self.filename, 'rb') as f:
self.assertEqual(f.read(), self.contents)
# Ensure the output is as expected
self.assertIn(
'Successfully downloaded log archive for game session '
'mysession to %s' % self.filename,
stdout
)
def setUp(self):
super(BaseLambdaTests, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file("foo", "mycontents")
self.zip_file = os.path.join(self.files.rootdir, "foo.zip")
with closing(zipfile.ZipFile(self.zip_file, "w")) as f:
f.write(self.temp_file)
with open(self.zip_file, "rb") as f:
self.zip_file_contents = f.read()
class TestParamFile(unittest.TestCase):
def setUp(self):
self.files = FileCreator()
def tearDown(self):
self.files.remove_all()
def get_paramfile(self, path):
return get_paramfile(path, LOCAL_PREFIX_MAP.copy())
def test_text_file(self):
contents = 'This is a test'
filename = self.files.create_file('foo', contents)
prefixed_filename = 'file://' + filename
data = self.get_paramfile(prefixed_filename)
self.assertEqual(data, contents)
self.assertIsInstance(data, six.string_types)
def test_binary_file(self):
contents = 'This is a test'
filename = self.files.create_file('foo', contents)
prefixed_filename = 'fileb://' + filename
data = self.get_paramfile(prefixed_filename)
self.assertEqual(data, b'This is a test')
self.assertIsInstance(data, six.binary_type)
@skip_if_windows('Binary content error only occurs '
'on non-Windows platforms.')
def test_cannot_load_text_file(self):
contents = b'\xbfX\xac\xbe'
filename = self.files.create_file('foo', contents, mode='wb')
prefixed_filename = 'file://' + filename
with self.assertRaises(ResourceLoadingError):
self.get_paramfile(prefixed_filename)
def test_file_does_not_exist_raises_error(self):
with self.assertRaises(ResourceLoadingError):
self.get_paramfile('file://file/does/not/existsasdf.txt')
def test_no_match_uris_returns_none(self):
self.assertIsNone(self.get_paramfile('foobar://somewhere.bar'))
def test_non_string_type_returns_none(self):
self.assertIsNone(self.get_paramfile(100))
def setUp(self):
super(BaseLambdaTests, self).setUp()
self.files = FileCreator()
self.temp_file = self.files.create_file(
'foo', 'mycontents')
self.zip_file = os.path.join(self.files.rootdir, 'foo.zip')
with closing(zipfile.ZipFile(self.zip_file, 'w')) as f:
f.write(self.temp_file)
with open(self.zip_file, 'rb') as f:
self.zip_file_contents = f.read()
def setUp(self):
self.files = FileCreator()
self.alias_file = self.files.create_file("alias", "[toplevel]\n")
self.alias_loader = AliasLoader(self.alias_file)
self.session = mock.Mock(spec=Session)
self.alias_cmd_injector = AliasCommandInjector(self.session, self.alias_loader)
self.command_table = {}
self.parser = MainArgParser(
command_table=self.command_table, version_string="version", description="description", argument_table={}
)
def setUp(self):
super(TestCLITimestampParser, self).setUp()
self.files = FileCreator()
self.wire_response = json.dumps({
'builds': [{
'startTime': 0,
}]
}).encode('utf-8')
self.command = ['codebuild', 'batch-get-builds', '--ids', 'foo']
self.patch_send(content=self.wire_response)
