def test_put_pipeline_definition_with_json(self):
     with temporary_file('r+') as f:
         f.write(TEST_JSON)
         f.flush()
         cmdline = self.prefix
         cmdline += ' --pipeline-id name'
         cmdline += ' --pipeline-definition file://%s' % f.name
         result = {
             'pipelineId': 'name',
             'pipelineObjects': [
                 {"id": "S3ToS3Copy",
                  "name": "S3ToS3Copy",
                  "fields": [
                    {
                      "key": "input",
                      "refValue": "InputData"
                    },
                    {
                      "key": "output",
                      "refValue": "OutputData"
                    },
                    {
                      "key": "schedule",
                      "refValue": "CopyPeriod"
                    },
                    {
                      "key": "type",
                      "stringValue": "CopyActivity"
                    },
                  ]}]
         }
         self.assert_params_for_cmd(cmdline, result)

    def test_credential_process_returns_error(self):
        config = (
            '[profile processcreds]\n'
            'credential_process = %s --raise-error\n'
        )
        config = config % self.credential_process
        with temporary_file('w') as f:
            f.write(config)
            f.flush()
            self.environ['AWS_CONFIG_FILE'] = f.name

            session = Session(profile='processcreds')

            # This regex validates that there is no substring: b'
            # The reason why we want to validate that is that we want to
            # make sure that stderr is actually decoded so that in
            # exceptional cases the error is properly formatted.
            # As for how the regex works:
            # `(?!b').` is a negative lookahead, meaning that it will only
            # match if it is not followed by the pattern `b'`. Since it is
            # followed by a `.` it will match any character not followed by
            # that pattern. `((?!hede).)*` does that zero or more times. The
            # final pattern adds `^` and `$` to anchor the beginning and end
            # of the string so we can know the whole string is consumed.
            # Finally `(?s)` at the beginning makes dots match newlines so
            # we can handle a multi-line string.
            reg = r"(?s)^((?!b').)*$"
            with self.assertRaisesRegexp(CredentialRetrievalError, reg):
                session.get_credentials()

    def test_can_specify_multiple_versions_from_config(self, client_creator):
        config_api_version = '2012-01-01'
        second_config_api_version = '2013-01-01'
        with temporary_file('w') as f:
            del self.environ['FOO_PROFILE']
            self.environ['FOO_CONFIG_FILE'] = f.name
            self.session = create_session(session_vars=self.env_vars)
            f.write('[default]\n')
            f.write('foo_api_versions =\n'
                    '    myservice = %s\n'
                    '    myservice2 = %s\n' % (
                        config_api_version, second_config_api_version)
            )
            f.flush()

            self.session.create_client('myservice', 'us-west-2')
            call_kwargs = client_creator.return_value.\
                create_client.call_args[1]
            self.assertEqual(call_kwargs['api_version'], config_api_version)

            self.session.create_client('myservice2', 'us-west-2')
            call_kwargs = client_creator.return_value.\
                create_client.call_args[1]
            self.assertEqual(
                call_kwargs['api_version'], second_config_api_version)

 def test_uri_param(self):
     p = self.get_param_object("ec2.DescribeInstances.Filters")
     with temporary_file("r+") as f:
         json_argument = json.dumps([{"Name": "instance-id", "Values": ["i-1234"]}])
         f.write(json_argument)
         f.flush()
         result = uri_param(p, "file://%s" % f.name)
     self.assertEqual(result, json_argument)

 def test_bucket_in_other_region_using_http(self):
     client = self.session.create_client("s3", "us-east-1", endpoint_url="http://s3.amazonaws.com/")
     with temporary_file("w") as f:
         f.write("foobarbaz" * 1024 * 1024)
         f.flush()
         with open(f.name, "rb") as body_file:
             response = client.put_object(Bucket=self.bucket_name, Key="foo.txt", Body=body_file)
         self.assert_status_code(response, 200)

 def test_with_csm_disabled_from_config(self):
     with temporary_file('w') as f:
         del self.environ['FOO_PROFILE']
         self.environ['FOO_CONFIG_FILE'] = f.name
         f.write('[default]\n')
         f.write('csm_enabled=false\n')
         f.flush()
         self.assert_created_client_is_not_monitored(self.session)

 def test_bucket_in_other_region_using_http(self):
     http_endpoint = self.service.get_endpoint(endpoint_url="http://s3.amazonaws.com/")
     with temporary_file("w") as f:
         f.write("foobarbaz" * 1024 * 1024)
         f.flush()
         op = self.service.get_operation("PutObject")
         response = op.call(http_endpoint, bucket=self.bucket_name, key="foo.txt", body=open(f.name, "rb"))
         self.assertEqual(response[0].status_code, 200)
         self.keys.append("foo.txt")

 def test_config_loader_delegation(self):
     with temporary_file('w') as f:
         f.write('[credfile-profile]\naws_access_key_id=a\n')
         f.write('aws_secret_access_key=b\n')
         f.flush()
         self.session.set_config_variable('credentials_file', f.name)
         self.session.profile = 'credfile-profile'
         # Now trying to retrieve the scoped config should not fail.
         self.assertEqual(self.session.get_scoped_config(), {})

 def test_bucket_in_other_region_using_http(self):
     client = self.session.create_client(
         's3', 'us-east-1', endpoint_url='http://s3.amazonaws.com/')
     with temporary_file('w') as f:
         f.write('foobarbaz' * 1024 * 1024)
         f.flush()
         with open(f.name, 'rb') as body_file:
             response = client.put_object(
                 Bucket=self.bucket_name,
                 Key='foo.txt', Body=body_file)
         self.assert_status_code(response, 200)

    def test_honors_aws_shared_credentials_file_env_var(self):
        with temporary_file('w') as f:
            f.write('[default]\n'
                    'aws_access_key_id=custom1\n'
                    'aws_secret_access_key=custom2\n')
            f.flush()
            os.environ['AWS_SHARED_CREDENTIALS_FILE'] = f.name
            s = Session()
            credentials = s.get_credentials()

            self.assertEqual(credentials.access_key, 'custom1')
            self.assertEqual(credentials.secret_key, 'custom2')

 def test_bucket_in_other_region(self):
     # This verifies expect 100-continue behavior.  We previously
     # had a bug where we did not support this behavior and trying to
     # create a bucket and immediately PutObject with a file like object
     # would actually cause errors.
     client = self.session.create_client("s3", "us-east-1")
     with temporary_file("w") as f:
         f.write("foobarbaz" * 1024 * 1024)
         f.flush()
         with open(f.name, "rb") as body_file:
             response = client.put_object(Bucket=self.bucket_name, Key="foo.txt", Body=body_file)
         self.assert_status_code(response, 200)

 def test_config_loader_delegation(self):
     session = create_session(profile='credfile-profile')
     with temporary_file('w') as f:
         f.write('[credfile-profile]\naws_access_key_id=a\n')
         f.write('aws_secret_access_key=b\n')
         f.flush()
         session.set_config_variable('credentials_file', f.name)
         # Now trying to retrieve the scoped config should pull in
         # values from the shared credentials file.
         self.assertEqual(session.get_scoped_config(),
                          {'aws_access_key_id': 'a',
                           'aws_secret_access_key': 'b'})

    def test_full_config_merges_creds_file_data(self):
        with temporary_file('w') as f:
            self.session.set_config_variable('credentials_file', f.name)
            f.write('[newprofile]\n')
            f.write('aws_access_key_id=FROM_CREDS_FILE_1\n')
            f.write('aws_secret_access_key=FROM_CREDS_FILE_2\n')
            f.flush()

            full_config = self.session.full_config
            self.assertEqual(full_config['profiles']['newprofile'],
                             {'aws_access_key_id': 'FROM_CREDS_FILE_1',
                              'aws_secret_access_key': 'FROM_CREDS_FILE_2'})

    def test_can_override_session(self):
        with temporary_file('w') as f:
            # We're going to override _retry.json in 
            # botocore/data by setting our own data directory.
            override_name = self.create_file(
                f, contents='{"foo": "bar"}', name='_retry.json')
            new_data_path = os.path.dirname(override_name)
            loader = loaders.create_loader(search_path_string=new_data_path)

            new_content = loader.load_data('_retry')
            # This should contain the content we just created.
            self.assertEqual(new_content, {"foo": "bar"})

 def test_bucket_in_other_region(self):
     # This verifies expect 100-continue behavior.  We previously
     # had a bug where we did not support this behavior and trying to
     # create a bucket and immediately PutObject with a file like object
     # would actually cause errors.
     with temporary_file("w") as f:
         f.write("foobarbaz" * 1024 * 1024)
         f.flush()
         op = self.service.get_operation("PutObject")
         response = op.call(self.endpoint, bucket=self.bucket_name, key="foo.txt", body=open(f.name, "rb"))
         self.assertEqual(response[0].status_code, 200)
         self.keys.append("foo.txt")

    def test_create_client_with_ca_bundle_from_config(self, client_creator):
        with temporary_file('w') as f:
            del self.environ['FOO_PROFILE']
            self.environ['FOO_CONFIG_FILE'] = f.name
            f.write('[default]\n')
            f.write('foo_ca_bundle=config-certs.pem\n')
            f.flush()

            self.session.create_client('ec2', 'us-west-2')
            call_kwargs = client_creator.return_value.\
                create_client.call_args[1]
            self.assertEqual(call_kwargs['verify'], 'config-certs.pem')

    def test_path_not_in_available_profiles(self):
        with temporary_file('w') as f:
            self.session.set_config_variable('credentials_file', f.name)
            f.write('[newprofile]\n')
            f.write('aws_access_key_id=FROM_CREDS_FILE_1\n')
            f.write('aws_secret_access_key=FROM_CREDS_FILE_2\n')
            f.flush()

            profiles = self.session.available_profiles
            self.assertEqual(
                set(profiles),
                set(['foo', 'default', 'newprofile']))

 def test_bucket_in_other_region_using_http(self):
     http_endpoint = self.service.get_endpoint(
         endpoint_url='http://s3.amazonaws.com/')
     with temporary_file('w') as f:
         f.write('foobarbaz' * 1024 * 1024)
         f.flush()
         op = self.service.get_operation('PutObject')
         response = op.call(http_endpoint,
                            bucket=self.bucket_name,
                            key='foo.txt',
                            body=open(f.name, 'rb'))
         self.assertEqual(response[0].status_code, 200)
         self.keys.append('foo.txt')

    def test_create_client_uses_api_version_from_config(self, client_creator):
        config_api_version = '2012-01-01'
        with temporary_file('w') as f:
            del self.environ['FOO_PROFILE']
            self.environ['FOO_CONFIG_FILE'] = f.name
            f.write('[default]\n')
            f.write('foo_api_versions =\n'
                    '    myservice = %s\n' % config_api_version)
            f.flush()

            self.session.create_client('myservice', 'us-west-2')
            call_kwargs = client_creator.return_value.\
                create_client.call_args[1]
            self.assertEqual(call_kwargs['api_version'], config_api_version)

    def test_credential_process(self):
        config = (
            '[profile processcreds]\n'
            'credential_process = %s\n'
        )
        config = config % self.credential_process
        with temporary_file('w') as f:
            f.write(config)
            f.flush()
            self.environ['AWS_CONFIG_FILE'] = f.name

            credentials = Session(profile='processcreds').get_credentials()
            self.assertEqual(credentials.access_key, 'spam')
            self.assertEqual(credentials.secret_key, 'eggs')