Python Mock.client方法代码示例

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
def sagemaker_session_stopped():
    boto_mock = Mock(name='boto_session')
    boto_mock.client('logs').describe_log_streams.return_value = DEFAULT_LOG_STREAMS
    boto_mock.client('logs').get_log_events.side_effect = DEFAULT_LOG_EVENTS
    ims = sagemaker.Session(boto_session=boto_mock, sagemaker_client=Mock())
    ims.sagemaker_client.describe_training_job.return_value = STOPPED_DESCRIBE_JOB_RESULT
    return ims

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
def test_ecr_login_needed(check_output):
    session_mock = Mock()

    token = 'very-secure-token'
    token_response = 'AWS:%s' % token
    b64_token = base64.b64encode(token_response.encode('utf-8'))
    response = {
        u'authorizationData':
            [
                {
                    u'authorizationToken': b64_token,
                    u'proxyEndpoint': u'https://520713654638.dkr.ecr.us-east-1.amazonaws.com'
                }
            ],
        'ResponseMetadata':
            {
                'RetryAttempts': 0,
                'HTTPStatusCode': 200,
                'RequestId': '25b2ac63-36bf-11e8-ab6a-e5dc597d2ad9',
            }
    }
    session_mock.client('ecr').get_authorization_token.return_value = response
    image = '520713654638.dkr.ecr.us-east-1.amazonaws.com/image-i-need:1.1'
    sagemaker.local.image._ecr_login_if_needed(session_mock, image)

    expected_command = 'docker login -u AWS -p %s https://520713654638.dkr.ecr.us-east-1.amazonaws.com' % token

    check_output.assert_called_with(expected_command, shell=True)
    session_mock.client('ecr').get_authorization_token.assert_called_with(registryIds=['520713654638'])

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
def sagemaker_session_full_lifecycle():
    boto_mock = Mock(name='boto_session')
    boto_mock.client('logs').describe_log_streams.side_effect = LIFECYCLE_LOG_STREAMS
    boto_mock.client('logs').get_log_events.side_effect = STREAM_LOG_EVENTS
    ims = sagemaker.Session(boto_session=boto_mock, sagemaker_client=Mock())
    ims.sagemaker_client.describe_training_job.side_effect = [IN_PROGRESS_DESCRIBE_JOB_RESULT,
                                                              IN_PROGRESS_DESCRIBE_JOB_RESULT,
                                                              COMPLETED_DESCRIBE_JOB_RESULT]
    return ims

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_should_not_include_files_outside_config_directory(self):

        mock_svn_service = Mock(SvnService)
        mock_svn_service.config_url = 'svn://url/for/configuration/repository'
        mock_svn_service.path_to_config = '/config'
        mock_svn_service.client = Mock()
        mock_info = Mock()

        mock_path_object_1 = Mock()
        mock_path_object_1.path = '/config/foo'
        mock_path_object_1.action = 'A'

        mock_path_object_2 = Mock()
        mock_path_object_2.path = '/XXXXXX/bar'
        mock_path_object_2.action = 'A'

        mock_path_object_3 = Mock()
        mock_path_object_3.path = '/XXX/foobar'
        mock_path_object_3.action = 'A'

        mock_info.changed_paths = [mock_path_object_1, mock_path_object_2, mock_path_object_3]
        mock_svn_service.get_logs_for_revision.return_value = [mock_info]

        actual = SvnService.get_changed_paths_with_action(mock_svn_service, '1980')

        self.assertEqual([('foo', 'A')], actual)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_sendEvent_should_use_kwargs_as_event_items(self):
        mock_broadcaster = Mock(WampBroadcaster)
        mock_broadcaster.target = "broadcaster-target"
        mock_broadcaster.logger = Mock()
        mock_broadcaster.client = Mock()

        WampBroadcaster._sendEvent(
            mock_broadcaster,
            "event-id",
            "event-data",
            tracking_id="tracking-id",
            target="target",
            state="foobar",
            bar="baz",
        )

        actual_call = mock_broadcaster.client.publish.call_args
        self.assertEqual(
            call(
                "target",
                {
                    "payload": "event-data",
                    "type": "event",
                    "id": "event-id",
                    "tracking_id": "tracking-id",
                    "target": "target",
                    "state": "foobar",
                    "bar": "baz",
                },
            ),
            actual_call,
        )

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_check_connection_should_return_true_when_link_is_up(self):
        mock_broadcaster = Mock(WampBroadcaster)
        mock_broadcaster.logger = Mock()
        mock_broadcaster.url = "ws://broadcaster"
        mock_broadcaster.client = Mock()

        self.assertEqual(WampBroadcaster._check_connection(mock_broadcaster), True)
        self.assertFalse(hasattr(mock_broadcaster, "not_connected_warning_sent"))

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_should_set_the_client_to_none(self, mock_log):
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_broadcaster.client = 'Test client'
        mock_receiver.broadcaster = mock_broadcaster

        Receiver.onConnectionLost(mock_receiver, 'Spam eggs.')

        self.assertEquals(None, mock_broadcaster.client)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
 def test_successfully_adds_kinesis_subscription(self, mocked_session):
     _mocked_lambda = Mock()
     _mocked_session = Mock()
     _mocked_session.client = Mock()
     _mocked_session.client.return_value = _mocked_lambda
     mocked_session.return_value = _mocked_session
     conf = config.Config(path.dirname(__file__),
                          config_file=path.join(EX_CONFIG, 'lambda-with-subscription.json'))
     subscribers.create_subscriptions(conf, None)
     nt.assert_equals(True, _mocked_lambda.create_event_source_mapping.called)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_should_raise_exception_when_pysvn_client_fails_to_log(self):

        mock_svn_service = Mock(SvnService)
        mock_svn_service.config_url = 'svn://url/for/configuration/repository/config'
        mock_svn_service.base_url = 'svn://url/for/configuration/repository'
        mock_svn_service.path_to_config = '/config'
        mock_svn_service.client = Mock()
        mock_svn_service.client.log.side_effect = Exception("Aaarrrgggghh...")

        self.assertRaises(SvnServiceException, SvnService.get_logs_for_revision, mock_svn_service, '1980')

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
 def test___init__(self):
     parser = common.CliOptions().create_optparser(False)
     common.AuthedCommandsBase.debug = True
     dbaas = Mock()
     dbaas.authenticate = Mock(return_value=None)
     dbaas.client = Mock()
     dbaas.client.auth_token = Mock()
     dbaas.client.service_url = Mock()
     dbaas.client.authenticate_with_token = Mock()
     common.AuthedCommandsBase._get_client = Mock(return_value=dbaas)
     authed_cmd = common.AuthedCommandsBase(parser)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
def test_download_file():
    boto_mock = Mock(name='boto_session')
    boto_mock.client('sts').get_caller_identity.return_value = {'Account': '123'}
    bucket_mock = Mock()
    boto_mock.resource('s3').Bucket.return_value = bucket_mock
    session = sagemaker.Session(boto_session=boto_mock, sagemaker_client=Mock())

    sagemaker_container = _SageMakerContainer('local', 2, 'my-image', sagemaker_session=session)
    sagemaker_container._download_file(BUCKET_NAME, '/prefix/path/file.tar.gz', '/tmp/file.tar.gz')

    bucket_mock.download_file.assert_called_with('prefix/path/file.tar.gz', '/tmp/file.tar.gz')

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_should_return_logs_for_revision(self):
        mock_svn_service = Mock(SvnService)
        mock_svn_service.base_url = 'svn://url/for/configuration/repository'
        mock_svn_service.path_to_config = '/config'
        mock_svn_service.client = Mock()
        mock_logs = Mock()
        mock_svn_service.client.log.return_value = mock_logs

        actual = SvnService.get_logs_for_revision(mock_svn_service, '1980')

        self.assertEqual(mock_logs, actual)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
def sagemaker_session():
    boto_mock = Mock(name='boto_session', region_name=REGION)
    boto_mock.client('sts').get_caller_identity.return_value = {'Account': '123'}
    boto_mock.resource('s3').Bucket(BUCKET_NAME).objects.filter.return_value = []

    sms = sagemaker.Session(boto_session=boto_mock, sagemaker_client=Mock())

    sms.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)
    sms.expand_role = Mock(return_value=EXPANDED_ROLE)

    return sms

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
    def test_attach(self):
        i = BaseIterator(name="test123", priority=111, classname="com.test.Class")

        it_s = i.get_iterator_setting()
        scopes = set([IteratorScope.SCAN, IteratorScope.MINC, IteratorScope.MAJC])

        conn = Mock()
        conn.client = Mock()
        conn.client.attachIterator = Mock()
        conn.login = "Login"

        i.attach(conn, "mytable123", scopes)
        conn.client.attachIterator.assert_called_with("Login", "mytable123", it_s, scopes)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import client [as 别名]
 def test_successfully_updates_kinesis_subscription(self, mocked_session):
     resonse = {"Error": {"Code": "ResourceConflictException", "Message": ""}}
     err = botocore.exceptions.ClientError(resonse, "create_event_source_mapping")
     _mocked_lambda = Mock()
     _mocked_lambda.create_event_source_mapping.side_effect = err
     _mocked_lambda.list_event_source_mappings.return_value = {
         'EventSourceMappings': [{'UUID': 'myuuid'}]
     }
     _mocked_session = Mock()
     _mocked_session.client = Mock()
     _mocked_session.client.return_value = _mocked_lambda
     mocked_session.return_value = _mocked_session
     conf = config.Config(path.dirname(__file__),
                          config_file=path.join(EX_CONFIG, 'lambda-with-subscription.json'))
     subscribers.create_subscriptions(conf, None)
     nt.assert_equals(True, _mocked_lambda.update_event_source_mapping.called)