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 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 = {'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()
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):
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)
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.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(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()
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()
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()
def setUp(self):
super(S3HandlerBaseTest, self).setUp()
self.session = self.driver.session
self.driver.session.register('before-call', self.before_call)
self.driver.session.register('before-parameter-build',
self.before_parameter_build)
self.client = self.session.create_client('s3', 'us-east-1')
self.source_client = self.session.create_client('s3', 'us-east-1')
self.file_creator = FileCreator()
def setUp(self):
self.environ = {}
self.environ_patch = patch('os.environ', self.environ)
self.environ_patch.start()
self.mock = MagicMock()
self.mock.get_config = MagicMock(return_value={'region': None})
self.file_creator = FileCreator()
self.loc_files = make_loc_files(self.file_creator)
self.bucket = 's3testbucket'
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(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 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.session = botocore.session.get_session(EnvironmentVariables)
self.client = self.session.create_client('s3', 'us-west-2')
self.source_client = self.session.create_client('s3', 'us-west-2')
params = {'region': 'us-west-2'}
self.s3_handler = S3Handler(self.session, params)
self.bucket = make_s3_files(self.session)
self.file_creator = FileCreator()
self.loc_files = make_loc_files(self.file_creator)
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):
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 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(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 setUp(self):
self.session = get_session()
self.files = FileCreator()
# Create our own loader for the unit test and not rely on the
# customer's actual ~/.aws/models nor the builtin botocore data
# directory.
self.customer_data_root = os.path.join(self.files.rootdir, 'customer')
os.mkdir(self.customer_data_root)
self.builtin_data_root = os.path.join(self.files.rootdir, 'builtin')
os.mkdir(self.builtin_data_root)
self.data_loader = Loader(
[self.customer_data_root, self.builtin_data_root],
include_default_search_paths=False)
self.data_loader.CUSTOMER_DATA_PATH = self.customer_data_root
self.session.register_component('data_loader', self.data_loader)
# Since we are using a custom data loader, we need to remove
# retries since these try to get loaded when the service model
# is loaded.
self.session.unregister('service-data-loaded',
register_retries_for_service)
# Add some models into the builtin model directory
# We are going to add two models. One with a matching service name
# and endpoint and another without.
self.matching_service = 'matching'
self.non_matching_service = 'nonmatching'
self.non_matching_prefix = 'nonmatching-prefix'
self.default_api_version = '2015-10-01'
matching_service_path = os.path.join(self.builtin_data_root,
self.matching_service,
self.default_api_version,
'service-2.json')
os.makedirs(os.path.dirname(matching_service_path))
non_matching_service_path = os.path.join(self.builtin_data_root,
self.non_matching_service,
self.default_api_version,
'service-2.json')
os.makedirs(os.path.dirname(non_matching_service_path))
# Write the models to the builtin directory
with open(matching_service_path, 'w') as f:
json.dump(
self._create_service_definition(self.matching_service,
self.default_api_version), f)
with open(non_matching_service_path, 'w') as f:
json.dump(
self._create_service_definition(self.non_matching_prefix,
self.default_api_version), f)
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()
def setUp(self):
super(S3HandlerBaseTest, self).setUp()
self.session = self.driver.session
self.driver.session.register('before-call', self.before_call)
self.driver.session.register('before-parameter-build',
self.before_parameter_build)
self.client = self.session.create_client('s3', 'us-east-1')
self.source_client = self.session.create_client('s3', 'us-east-1')
self.file_creator = FileCreator()
self._saved_min_chunksize = utils.MIN_UPLOAD_CHUNKSIZE
utils.MIN_UPLOAD_CHUNKSIZE = 1
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(CommandArchitectureTest, self).setUp()
self.session = self.driver.session
self.bucket = 'mybucket'
self.file_creator = FileCreator()
self.loc_files = make_loc_files(self.file_creator)
self.output = StringIO()
self.err_output = StringIO()
self.saved_stdout = sys.stdout
self.saved_stderr = sys.stderr
sys.stdout = self.output
sys.stderr = self.err_output
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 setUp(self):
self.session = botocore.session.get_session(EnvironmentVariables)
self.client = self.session.create_client('s3', 'us-west-2')
params = {'region': 'us-west-2', 'acl': ['private']}
self.s3_handler = S3Handler(self.session, params)
self.s3_handler_multi = S3Handler(
self.session, params=params,
runtime_config=runtime_config(
multipart_threshold=10, multipart_chunksize=2))
self.bucket = create_bucket(self.session)
self.file_creator = FileCreator()
self.loc_files = make_loc_files(self.file_creator)
self.s3_files = [self.bucket + '/text1.txt',
self.bucket + '/another_directory/text2.txt']
self.output = StringIO()
self.saved_stderr = sys.stderr
sys.stderr = self.output
def setUp(self):
self.session = mock.Mock()
self.file_creator = FileCreator()
self.tags_dict = {}
# Make a temporary json index to base information on
self.json_index = self.file_creator.create_file('index.json', '')
with open(self.json_index, 'w') as f:
json.dump(self.tags_dict, f, indent=4, sort_keys=True)
self.index_patch = mock.patch('awscli.topictags.TopicTagDB.index_file',
self.json_index)
self.dir_patch = mock.patch('awscli.topictags.TopicTagDB.topic_dir',
self.file_creator.rootdir)
self.index_patch.start()
self.dir_patch.start()
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 setUp(self):
self.session = botocore.session.get_session(EnvironmentVariables)
self.client = self.session.create_client('s3', 'us-west-2')
params = {'region': 'us-west-2'}
self.s3_handler = S3Handler(self.session, params)
self.s3_handler_multi = S3Handler(
self.session, params,
runtime_config=runtime_config(multipart_threshold=10,
multipart_chunksize=2))
self.bucket = make_s3_files(self.session)
self.s3_files = [self.bucket + '/text1.txt',
self.bucket + '/another_directory/text2.txt']
self.file_creator = FileCreator()
directory1 = self.file_creator.rootdir + os.sep + 'some_directory' + \
os.sep
filename1 = directory1 + "text1.txt"
directory2 = directory1 + 'another_directory' + os.sep
filename2 = directory2 + "text2.txt"
self.loc_files = [filename1, filename2]
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
