def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn
class TestCanRefreshCheck(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn def test_true(self): tmp = self.mock_conn.describe_trusted_advisor_check_refresh_statuses chkstat = { 'checkId': 'abc123', 'status': 'none', 'millisUntilNextRefreshable': 0 } tmp.return_value = {'statuses': [chkstat]} with patch('%s.logger' % pbm, autospec=True) as mock_logger: res = self.cls._can_refresh_check('abc123') assert res is True assert tmp.mock_calls == [call(checkIds=['abc123'])] assert mock_logger.mock_calls == [ call.debug('TA Check %s refresh status: %s', 'abc123', chkstat) ] def test_false(self): tmp = self.mock_conn.describe_trusted_advisor_check_refresh_statuses chkstat = { 'checkId': 'abc123', 'status': 'none', 'millisUntilNextRefreshable': 123456 } tmp.return_value = {'statuses': [chkstat]} with patch('%s.logger' % pbm, autospec=True) as mock_logger: res = self.cls._can_refresh_check('abc123') assert res is False assert tmp.mock_calls == [call(checkIds=['abc123'])] assert mock_logger.mock_calls == [ call.debug('TA Check %s refresh status: %s', 'abc123', chkstat), call.warning( "Trusted Advisor check cannot be refreshed for " "another %d milliseconds; skipping refresh and " "getting check results now", 123456) ] def test_exception(self): tmp = self.mock_conn.describe_trusted_advisor_check_refresh_statuses chkstat = {'checkId': 'abc123', 'status': 'none'} tmp.return_value = {'statuses': [chkstat]} with patch('%s.logger' % pbm, autospec=True) as mock_logger: res = self.cls._can_refresh_check('abc123') assert res is True assert tmp.mock_calls == [call(checkIds=['abc123'])] assert mock_logger.mock_calls == [ call.debug('TA Check %s refresh status: %s', 'abc123', chkstat), call.warning('Could not get refresh status for TA check %s', 'abc123', exc_info=True) ]
def test_connect(self): cls = TrustedAdvisor() mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn assert mock_connect.mock_calls == [call()]
def test_connect_again(self): cls = TrustedAdvisor() mock_original_conn = Mock(spec_set=SupportConnection) cls.conn = mock_original_conn mock_conn = Mock(spec_set=SupportConnection) with patch('awslimitchecker.trustedadvisor.boto.connect_support' '') as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_original_conn assert mock_connect.mock_calls == []
def setup(self): self.mock_conn = Mock(spec_set=SupportConnection) type(self.mock_conn).region = RegionInfo(name='us-east-1') self.cls = TrustedAdvisor() self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, }
def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor() self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, }
def test_boto_kwargs(self): mock_svc = Mock(spec_set=_AwsService) mock_svc.get_limits.return_value = {} boto_args = dict(region_name='myregion', aws_access_key_id='myaccesskey', aws_secret_access_key='mysecretkey', aws_session_token='mytoken') cls = TrustedAdvisor( {'foo': mock_svc}, boto_args, ta_refresh_mode=123, ta_refresh_timeout=456 ) assert cls.conn is None cls_boto_args = cls._boto3_connection_kwargs assert cls_boto_args.get('region_name') == 'us-east-1' assert cls_boto_args.get('aws_access_key_id') == 'myaccesskey' assert cls_boto_args.get('aws_secret_access_key') == 'mysecretkey' assert cls_boto_args.get('aws_session_token') == 'mytoken' assert cls.ta_region == 'myregion' assert cls.all_services == {'foo': mock_svc} assert cls.limits_updated is False assert cls.refresh_mode == 123 assert cls.refresh_timeout == 456
def test_connect_region(self): cls = TrustedAdvisor(account_id='foo', account_role='bar', region='re') mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') mock_conn_via = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.TrustedAdvisor.connect_via' '') as mock_connect_via: mock_connect_via.return_value = mock_conn_via with patch('awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn_via assert mock_connect.mock_calls == [] assert mock_connect_via.mock_calls == [ call(connect_to_region) ]
def test_connect_region(self): cls = TrustedAdvisor(account_id='foo', account_role='bar', region='re') mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') mock_conn_via = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.TrustedAdvisor.connect_via' '') as mock_connect_via: mock_connect_via.return_value = mock_conn_via with patch( 'awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn_via assert mock_connect.mock_calls == [] assert mock_connect_via.mock_calls == [call(connect_to_region)]
class TestUpdateLimits(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_simple(self): mock_results = Mock() with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: mock_poll.return_value = mock_results self.cls.update_limits() assert mock_connect.mock_calls == [call(self.cls)] assert mock_poll.mock_calls == [call(self.cls)] assert mock_update_services.mock_calls == [ call(self.cls, mock_results) ] def test_again(self): mock_results = Mock() self.cls.limits_updated = True with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: with patch('%s.logger' % pbm) as mock_logger: mock_poll.return_value = mock_results self.cls.update_limits() assert mock_connect.mock_calls == [] assert mock_poll.mock_calls == [] assert mock_update_services.mock_calls == [] assert mock_logger.mock_calls == [ call.debug('Already polled TA; skipping update') ]
def test_init_sts(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id is None
def test_simple(self): cls = TrustedAdvisor({}, {}) assert cls.conn is None assert cls._boto3_connection_kwargs == {'region_name': 'us-east-1'} assert cls.all_services == {} assert cls.limits_updated is False assert cls.refresh_mode is None assert cls.refresh_timeout is None
def test_init(self): cls = TrustedAdvisor() assert cls.conn is None assert cls.account_id is None assert cls.account_role is None assert cls.region == 'us-east-1' assert cls.ta_region is None assert cls.external_id is None
def test_init(self): cls = TrustedAdvisor({}) assert cls.conn is None assert cls.account_id is None assert cls.account_role is None assert cls.region == 'us-east-1' assert cls.ta_region is None assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None assert cls.all_services == {} assert cls.limits_updated is False
def test_init_sts_external_id(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r', external_id='myeid') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id == 'myeid' assert cls.mfa_serial_number is None assert cls.mfa_token is None
def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, }
def test_init_sts(self): mock_svc = Mock(spec_set=_AwsService) mock_svc.get_limits.return_value = {} cls = TrustedAdvisor({'foo': mock_svc}, account_id='aid', account_role='role', region='r') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None assert cls.all_services == {'foo': mock_svc} assert cls.limits_updated is False
class Test_TrustedAdvisor(object): def setup(self): self.mock_conn = Mock(spec_set=SupportConnection) type(self.mock_conn).region = RegionInfo(name='us-east-1') self.cls = TrustedAdvisor() self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_init(self): cls = TrustedAdvisor() assert cls.conn is None def test_connect(self): cls = TrustedAdvisor() mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn assert mock_connect.mock_calls == [call()] def test_connect_again(self): cls = TrustedAdvisor() mock_original_conn = Mock(spec_set=SupportConnection) cls.conn = mock_original_conn mock_conn = Mock(spec_set=SupportConnection) with patch('awslimitchecker.trustedadvisor.boto.connect_support' '') as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_original_conn assert mock_connect.mock_calls == [] def test_update_limits(self): mock_results = Mock() with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: mock_poll.return_value = mock_results self.cls.update_limits(self.services) assert mock_connect.mock_calls == [call(self.cls)] assert mock_poll.mock_calls == [call(self.cls)] assert mock_update_services.mock_calls == [ call(self.cls, mock_results, self.services) ] def test_get_limit_check_id(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Service Limits', 'id': 'bar', 'metadata': [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ], }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == ( 'bar', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ] ) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks('en') ] def test_get_limit_check_id_none(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Something Else', 'id': 'bar', }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks('en') ] def test_get_limit_check_id_subscription_required(self): def se_api(language): status = 400 reason = 'Bad Request' body = { 'message': 'AWS Premium Support Subscription is required to ' 'use this service.', '__type': 'SubscriptionRequiredException' } raise JSONResponseError(status, reason, body) self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api assert self.cls.have_ta is True with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._get_limit_check_id() assert self.cls.have_ta is False assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks('en') ] assert mock_logger.mock_calls == [ call.debug("Querying Trusted Advisor checks"), call.warning("Cannot check TrustedAdvisor: %s", "AWS Premium Support " "Subscription is required to use this service.") ] def test_get_limit_check_id_other_exception(self): def se_api(language): status = 400 reason = 'foobar' body = { 'message': 'other message', '__type': 'OtherException' } raise JSONResponseError(status, reason, body) self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with pytest.raises(BotoServerError) as excinfo: self.cls._get_limit_check_id() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks('en') ] assert excinfo.value.status == 400 assert excinfo.value.reason == 'foobar' assert excinfo.value.body['__type'] == 'OtherException' def test_poll_id_none(self): tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = None self.cls._poll() assert tmp.mock_calls == [] def test_poll(self): tmp = self.mock_conn.describe_trusted_advisor_check_result tmp.return_value = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = ( 'foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ] ) res = self.cls._poll() assert tmp.mock_calls == [call('foo')] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, } } def test_poll_dont_have_ta(self): self.cls.have_ta = False tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._poll() assert tmp.mock_calls == [] assert mock_id.mock_calls == [ call(self.cls) ] assert mock_logger.mock_calls == [ call.info('Beginning TrustedAdvisor poll'), call.info('TrustedAdvisor.have_ta is False; not polling TA') ] assert res == {} def test_update_services(self): def se_set(lname, val): if lname == 'blam': raise ValueError("foo") mock_autoscale = Mock(spec_set=_AwsService) mock_ec2 = Mock(spec_set=_AwsService) mock_ec2._set_ta_limit.side_effect = se_set services = { 'AutoScaling': mock_autoscale, 'EC2': mock_ec2, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, 'blam': 10, }, 'OtherService': { 'blarg': 1, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls._update_services(ta_results, services) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info("TrustedAdvisor returned check results for unknown " "limit '%s' (service %s)", 'blam', 'EC2'), call.info("TrustedAdvisor returned check results for unknown " "service '%s'", 'OtherService'), call.info("Done updating TA limits on all services"), ] assert mock_autoscale.mock_calls == [ call._set_ta_limit('bar', 40), call._set_ta_limit('foo', 20), ] assert mock_ec2.mock_calls == [ call._set_ta_limit('baz', 5), call._set_ta_limit('blam', 10), ]
class Test_TrustedAdvisor(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_init(self): cls = TrustedAdvisor({}) assert cls.conn is None assert cls.account_id is None assert cls.account_role is None assert cls.region == 'us-east-1' assert cls.ta_region is None assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None assert cls.all_services == {} assert cls.limits_updated is False def test_init_sts(self): mock_svc = Mock(spec_set=_AwsService) mock_svc.get_limits.return_value = {} cls = TrustedAdvisor( {'foo': mock_svc}, account_id='aid', account_role='role', region='r' ) assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None assert cls.all_services == {'foo': mock_svc} assert cls.limits_updated is False def test_init_sts_external_id(self): cls = TrustedAdvisor( {}, account_id='aid', account_role='role', region='r', external_id='myeid' ) assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id == 'myeid' assert cls.mfa_serial_number is None assert cls.mfa_token is None assert cls.limits_updated is False def test_update_limits(self): mock_results = Mock() with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: mock_poll.return_value = mock_results self.cls.update_limits() assert mock_connect.mock_calls == [call(self.cls)] assert mock_poll.mock_calls == [call(self.cls)] assert mock_update_services.mock_calls == [ call(self.cls, mock_results) ] def test_update_limits_again(self): mock_results = Mock() self.cls.limits_updated = True with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: with patch('%s.logger' % pbm) as mock_logger: mock_poll.return_value = mock_results self.cls.update_limits() assert mock_connect.mock_calls == [] assert mock_poll.mock_calls == [] assert mock_update_services.mock_calls == [] assert mock_logger.mock_calls == [ call.debug('Already polled TA; skipping update') ] def test_get_limit_check_id(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Service Limits', 'id': 'bar', 'metadata': [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ], }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == ( 'bar', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ] ) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_get_limit_check_id_none(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Something Else', 'id': 'bar', }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_get_limit_check_id_subscription_required(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'AWS Premium Support Subscription is required ' 'to use this service.', 'Code': 'SubscriptionRequiredException' } } raise ClientError(response, 'operation') assert self.cls.have_ta is True self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._get_limit_check_id() assert self.cls.have_ta is False assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert mock_logger.mock_calls == [ call.debug("Querying Trusted Advisor checks"), call.warning("Cannot check TrustedAdvisor: %s", 'AWS Premium Support Subscription is required to ' 'use this service.') ] def test_get_limit_check_id_other_exception(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'foo', 'Code': 'SomeOtherException' } } raise ClientError(response, 'operation') self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with pytest.raises(ClientError) as excinfo: self.cls._get_limit_check_id() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert excinfo.value.response['ResponseMetadata'][ 'HTTPStatusCode'] == 400 assert excinfo.value.response['Error']['Message'] == 'foo' assert excinfo.value.response['Error']['Code'] == 'SomeOtherException' def test_poll_id_none(self): tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = None res = self.cls._poll() assert tmp.mock_calls == [] assert res is None def test_poll(self): tmp = self.mock_conn.describe_trusted_advisor_check_result poll_return_val = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid4', 'isSuppressed': False, 'metadata': [ '-', 'IAM', 'Users', '5000', '152', 'Green' ] }, ] } } tmp.return_value = poll_return_val with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = ( 'foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ] ) res = self.cls._poll() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_result( checkId='foo', language='en' ) ] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, }, 'IAM': { 'Users': 5000 } } def test_poll_region(self): tmp = self.mock_conn.describe_trusted_advisor_check_result self.cls.ta_region = 'us-west-2' poll_return_value = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid4', 'isSuppressed': False, 'metadata': [ '-', 'IAM', 'Users', '5000', '152', 'Green' ] }, ] } } tmp.return_value = poll_return_value with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = ( 'foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ] ) res = self.cls._poll() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_result( checkId='foo', language='en' ) ] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Auto Scaling groups': 20, }, 'IAM': { 'Users': 5000 } } def test_poll_dont_have_ta(self): self.cls.have_ta = False tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert tmp.mock_calls == [] assert mock_id.mock_calls == [ call(self.cls) ] assert mock_logger.mock_calls == [ call.info('Beginning TrustedAdvisor poll'), call.info('TrustedAdvisor.have_ta is False; not polling TA') ] assert res == {} def test_update_services(self): mock_as_foo = Mock(spec_set=AwsLimit) mock_as_bar = Mock(spec_set=AwsLimit) mock_ec2_baz = Mock(spec_set=AwsLimit) mock_vpc = Mock(spec_set=AwsLimit) ta_services = { 'AutoScaling': { 'foo': mock_as_foo, 'bar': mock_as_bar }, 'EC2': { 'baz': mock_ec2_baz }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': mock_vpc }, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, 'blam': 10, }, 'OtherService': { 'blarg': 1, }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': 11, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls.ta_services = ta_services self.cls._update_services(ta_results) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info("TrustedAdvisor returned check results for unknown " "limit '%s' (service %s)", 'blam', 'EC2'), call.info("TrustedAdvisor returned check results for unknown " "service '%s'", 'OtherService'), call.info("Done updating TA limits on all services"), ] assert mock_as_foo.mock_calls == [ call._set_ta_limit(20) ] assert mock_as_bar.mock_calls == [ call._set_ta_limit(40) ] assert mock_ec2_baz.mock_calls == [ call._set_ta_limit(5) ] assert mock_vpc.mock_calls == [ call._set_ta_limit(11) ] def test_make_ta_service_dict(self): mock_ec2 = Mock(spec_set=_AwsService) mock_el1 = Mock(spec_set=AwsLimit) type(mock_el1).name = 'el1' type(mock_el1).ta_service_name = 'EC2' type(mock_el1).ta_limit_name = 'el1' mock_el2 = Mock(spec_set=AwsLimit) type(mock_el2).name = 'el2' type(mock_el2).ta_service_name = 'Foo' type(mock_el2).ta_limit_name = 'el2' mock_ec2.get_limits.return_value = { 'mock_el1': mock_el1, 'mock_el2': mock_el2 } mock_vpc = Mock(spec_set=_AwsService) mock_vl1 = Mock(spec_set=AwsLimit) type(mock_vl1).name = 'vl1' type(mock_vl1).ta_service_name = 'VPC' type(mock_vl1).ta_limit_name = 'other name' mock_vl2 = Mock(spec_set=AwsLimit) type(mock_vl2).name = 'vl2' type(mock_vl2).ta_service_name = 'Foo' type(mock_vl2).ta_limit_name = 'other limit' mock_vpc.get_limits.return_value = { 'mock_vl1': mock_vl1, 'mock_vl2': mock_vl2 } svcs = { 'EC2': mock_ec2, 'VPC': mock_vpc } expected = { 'EC2': { 'el1': mock_el1 }, 'VPC': { 'other name': mock_vl1 }, 'Foo': { 'el2': mock_el2, 'other limit': mock_vl2 } } self.cls.all_services = svcs assert self.cls._make_ta_service_dict() == expected
class TestUpdateServices(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_simple(self): mock_as_foo = Mock(spec_set=AwsLimit) mock_as_bar = Mock(spec_set=AwsLimit) mock_ec2_baz = Mock(spec_set=AwsLimit) mock_ec2_blarg = Mock(spec_set=AwsLimit) mock_vpc = Mock(spec_set=AwsLimit) ta_services = { 'AutoScaling': { 'foo': mock_as_foo, 'bar': mock_as_bar }, 'EC2': { 'baz': mock_ec2_baz, 'blarg': mock_ec2_blarg }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': mock_vpc }, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, 'blam': 10, 'blarg': 'Unlimited', }, 'OtherService': { 'blarg': 1, }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': 11, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls.ta_services = ta_services self.cls._update_services(ta_results) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info( "TrustedAdvisor returned check results for unknown " "limit '%s' (service %s)", 'blam', 'EC2'), call.info( "TrustedAdvisor returned check results for unknown " "service '%s'", 'OtherService'), call.info("Done updating TA limits on all services"), ] assert mock_as_foo.mock_calls == [call._set_ta_limit(20)] assert mock_as_bar.mock_calls == [call._set_ta_limit(40)] assert mock_ec2_baz.mock_calls == [call._set_ta_limit(5)] assert mock_ec2_blarg.mock_calls == [call._set_ta_unlimited()] assert mock_vpc.mock_calls == [call._set_ta_limit(11)]
class TestMakeTAServiceDict(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_simple(self): mock_ec2 = Mock(spec_set=_AwsService) mock_el1 = Mock(spec_set=AwsLimit) type(mock_el1).name = 'el1' type(mock_el1).ta_service_name = 'EC2' type(mock_el1).ta_limit_name = 'el1' mock_el2 = Mock(spec_set=AwsLimit) type(mock_el2).name = 'el2' type(mock_el2).ta_service_name = 'Foo' type(mock_el2).ta_limit_name = 'el2' mock_ec2.get_limits.return_value = { 'mock_el1': mock_el1, 'mock_el2': mock_el2 } mock_vpc = Mock(spec_set=_AwsService) mock_vl1 = Mock(spec_set=AwsLimit) type(mock_vl1).name = 'vl1' type(mock_vl1).ta_service_name = 'VPC' type(mock_vl1).ta_limit_name = 'other name' mock_vl2 = Mock(spec_set=AwsLimit) type(mock_vl2).name = 'vl2' type(mock_vl2).ta_service_name = 'Foo' type(mock_vl2).ta_limit_name = 'other limit' mock_vpc.get_limits.return_value = { 'mock_vl1': mock_vl1, 'mock_vl2': mock_vl2 } svcs = {'EC2': mock_ec2, 'VPC': mock_vpc} expected = { 'EC2': { 'el1': mock_el1 }, 'VPC': { 'other name': mock_vl1 }, 'Foo': { 'el2': mock_el2, 'other limit': mock_vl2 } } self.cls.all_services = svcs assert self.cls._make_ta_service_dict() == expected
class TestGetLimitCheckId(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_simple(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Service Limits', 'id': 'bar', 'metadata': [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ], }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == ('bar', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_none(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Something Else', 'id': 'bar', }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_subscription_required(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'AWS Premium Support Subscription is required ' 'to use this service.', 'Code': 'SubscriptionRequiredException' } } raise ClientError(response, 'operation') assert self.cls.have_ta is True self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._get_limit_check_id() assert self.cls.have_ta is False assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert mock_logger.mock_calls == [ call.debug("Querying Trusted Advisor checks"), call.warning( "Cannot check TrustedAdvisor: %s", 'AWS Premium Support Subscription is required to ' 'use this service.') ] def test_other_exception(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'foo', 'Code': 'SomeOtherException' } } raise ClientError(response, 'operation') self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with pytest.raises(ClientError) as excinfo: self.cls._get_limit_check_id() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert excinfo.value.response['ResponseMetadata'][ 'HTTPStatusCode'] == 400 assert excinfo.value.response['Error']['Message'] == 'foo' assert excinfo.value.response['Error']['Code'] == 'SomeOtherException'
class Test_TrustedAdvisor(object): def setup(self): self.mock_conn = Mock(spec_set=SupportConnection) type(self.mock_conn).region = RegionInfo(name='us-east-1') self.cls = TrustedAdvisor() self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_init(self): cls = TrustedAdvisor() assert cls.conn is None assert cls.account_id is None assert cls.account_role is None assert cls.region == 'us-east-1' assert cls.ta_region is None assert cls.external_id is None def test_init_sts(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id is None def test_init_sts_external_id(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r', external_id='myeid') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id == 'myeid' def test_connect(self): cls = TrustedAdvisor() mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn assert mock_connect.mock_calls == [call()] def test_connect_region(self): cls = TrustedAdvisor(account_id='foo', account_role='bar', region='re') mock_conn = Mock(spec_set=SupportConnection, name='mock_conn') mock_conn_via = Mock(spec_set=SupportConnection, name='mock_conn') with patch('awslimitchecker.trustedadvisor.TrustedAdvisor.connect_via' '') as mock_connect_via: mock_connect_via.return_value = mock_conn_via with patch( 'awslimitchecker.trustedadvisor.boto.connect_support' '', autospec=True) as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_conn_via assert mock_connect.mock_calls == [] assert mock_connect_via.mock_calls == [call(connect_to_region)] def test_connect_again(self): cls = TrustedAdvisor() mock_original_conn = Mock(spec_set=SupportConnection) cls.conn = mock_original_conn mock_conn = Mock(spec_set=SupportConnection) with patch('awslimitchecker.trustedadvisor.boto.connect_support' '') as mock_connect: mock_connect.return_value = mock_conn cls.connect() assert cls.conn == mock_original_conn assert mock_connect.mock_calls == [] def test_update_limits(self): mock_results = Mock() with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: mock_poll.return_value = mock_results self.cls.update_limits(self.services) assert mock_connect.mock_calls == [call(self.cls)] assert mock_poll.mock_calls == [call(self.cls)] assert mock_update_services.mock_calls == [ call(self.cls, mock_results, self.services) ] def test_get_limit_check_id(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Service Limits', 'id': 'bar', 'metadata': [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ], }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_wrapper.return_value = api_resp res = self.cls._get_limit_check_id() assert res == ('bar', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) assert self.mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(self.mock_conn.describe_trusted_advisor_checks, 'en') ] def test_get_limit_check_id_none(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Something Else', 'id': 'bar', }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_wrapper.return_value = api_resp res = self.cls._get_limit_check_id() assert res == (None, None) assert self.mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(self.mock_conn.describe_trusted_advisor_checks, 'en') ] def test_get_limit_check_id_subscription_required(self): def se_api(foo, language): status = 400 reason = 'Bad Request' body = { 'message': 'AWS Premium Support Subscription is required to ' 'use this service.', '__type': 'SubscriptionRequiredException' } raise JSONResponseError(status, reason, body) assert self.cls.have_ta is True with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_wrapper.side_effect = se_api res = self.cls._get_limit_check_id() assert self.cls.have_ta is False assert res == (None, None) assert self.mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(self.mock_conn.describe_trusted_advisor_checks, 'en') ] assert mock_logger.mock_calls == [ call.debug("Querying Trusted Advisor checks"), call.warning( "Cannot check TrustedAdvisor: %s", "AWS Premium Support " "Subscription is required to use this service.") ] def test_get_limit_check_id_other_exception(self): def se_api(foo, language): status = 400 reason = 'foobar' body = {'message': 'other message', '__type': 'OtherException'} raise JSONResponseError(status, reason, body) with pytest.raises(BotoServerError) as excinfo: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_wrapper.side_effect = se_api self.cls._get_limit_check_id() assert self.mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(self.mock_conn.describe_trusted_advisor_checks, 'en') ] assert excinfo.value.status == 400 assert excinfo.value.reason == 'foobar' assert excinfo.value.body['__type'] == 'OtherException' def test_poll_id_none(self): tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_id.return_value = None res = self.cls._poll() assert tmp.mock_calls == [] assert mock_wrapper.mock_calls == [] assert res is None def test_poll(self): tmp = self.mock_conn.describe_trusted_advisor_check_result poll_return_val = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) mock_wrapper.return_value = poll_return_val res = self.cls._poll() assert tmp.mock_calls == [] assert mock_wrapper.mock_calls == [call(tmp, 'foo')] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, } } def test_poll_region(self): tmp = self.mock_conn.describe_trusted_advisor_check_result self.cls.ta_region = 'us-west-2' poll_return_value = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) mock_wrapper.return_value = poll_return_value res = self.cls._poll() assert tmp.mock_calls == [] assert mock_wrapper.mock_calls == [call(tmp, 'foo')] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Auto Scaling groups': 20, } } def test_poll_dont_have_ta(self): self.cls.have_ta = False tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s.boto_query_wrapper' % pbm) as mock_wrapper: with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._poll() assert mock_wrapper.mock_calls == [] assert tmp.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_logger.mock_calls == [ call.info('Beginning TrustedAdvisor poll'), call.info('TrustedAdvisor.have_ta is False; not polling TA') ] assert res == {} def test_update_services(self): def se_set(lname, val): if lname == 'blam': raise ValueError("foo") mock_autoscale = Mock(spec_set=_AwsService) mock_ec2 = Mock(spec_set=_AwsService) mock_ec2._set_ta_limit.side_effect = se_set mock_vpc = Mock(spec_set=_AwsService) services = { 'AutoScaling': mock_autoscale, 'EC2': mock_ec2, 'VPC': mock_vpc, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, 'blam': 10, }, 'OtherService': { 'blarg': 1, }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': 11, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls._update_services(ta_results, services) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info( "TrustedAdvisor returned check results for unknown " "limit '%s' (service %s)", 'blam', 'EC2'), call.info( "TrustedAdvisor returned check results for unknown " "service '%s'", 'OtherService'), call.info("Done updating TA limits on all services"), ] assert mock_autoscale.mock_calls == [ call._set_ta_limit('bar', 40), call._set_ta_limit('foo', 20), ] assert mock_ec2.mock_calls == [ call._set_ta_limit('baz', 5), call._set_ta_limit('blam', 10), call._set_ta_limit('VPC Elastic IP addresses (EIPs)', 11) ]
class TestPoll(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_none(self): tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = None res = self.cls._poll() assert tmp.mock_calls == [] assert res is None def test_basic(self): poll_return_val = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'EC2', 'On-Demand instances - t2.micro', 'Unlimited', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'EC2', 'On-Demand instances - t2.small', 'error', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid4', 'isSuppressed': False, 'metadata': ['-', 'IAM', 'Users', '5000', '152', 'Green'] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s._get_refreshed_check_result' % pb, autospec=True) as mock_hr: mock_hr.return_value = poll_return_val mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_hr.mock_calls == [call(self.cls, 'foo')] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, }, 'EC2': { 'On-Demand instances - t2.micro': 'Unlimited' }, 'IAM': { 'Users': 5000 } } def test_no_timestamp(self): poll_return_val = { 'result': { 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'EC2', 'On-Demand instances - t2.micro', 'Unlimited', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'EC2', 'On-Demand instances - t2.small', 'error', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid4', 'isSuppressed': False, 'metadata': ['-', 'IAM', 'Users', '5000', '152', 'Green'] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s._get_refreshed_check_result' % pb, autospec=True) as mock_hr: mock_hr.return_value = poll_return_val mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_hr.mock_calls == [call(self.cls, 'foo')] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, }, 'EC2': { 'On-Demand instances - t2.micro': 'Unlimited' }, 'IAM': { 'Users': 5000 } } def test_region(self): self.cls.ta_region = 'us-west-2' poll_return_value = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid4', 'isSuppressed': False, 'metadata': ['-', 'IAM', 'Users', '5000', '152', 'Green'] }, ] } } with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s._get_refreshed_check_result' % pb, autospec=True) as mock_hr: mock_hr.return_value = poll_return_value mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_hr.mock_calls == [call(self.cls, 'foo')] assert res == { 'AutoScaling': { 'Auto Scaling groups': 20, }, 'IAM': { 'Users': 5000 } } def test_dont_have_ta(self): self.cls.have_ta = False with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('%s._get_refreshed_check_result' % pb, autospec=True) as mock_hr: with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_hr.mock_calls == [] assert mock_logger.mock_calls == [ call.info('Beginning TrustedAdvisor poll'), call.info('TrustedAdvisor.have_ta is False; not polling TA') ] assert res == {}
class TestGetRefreshedCheckResult(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_mode_none(self): self.cls.refresh_mode = None with patch('%s._get_check_result' % pb, autospec=True) as mock_gcr: with patch('%s._can_refresh_check' % pb, autospec=True) as mock_crc: with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s._poll_for_refresh' % pb, autospec=True) as mock_pfr: mock_gcr.return_value = ({'mock': 'gcr'}, None) res = self.cls._get_refreshed_check_result('abc123') assert res == {'mock': 'gcr'} assert mock_gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_crc.mock_calls == [] assert mock_pfr.mock_calls == [] assert mock_logger.mock_calls == [ call.info("Not refreshing Trusted Advisor check (refresh mode is " "None)") ] @freeze_time("2016-12-16 10:40:42", tz_offset=0) def test_mode_int(self): self.cls.refresh_mode = 120 # 2 minutes check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) with patch('%s._get_check_result' % pb, autospec=True) as mock_gcr: with patch('%s._can_refresh_check' % pb, autospec=True) as mock_crc: with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s._poll_for_refresh' % pb, autospec=True) as mock_pfr: mock_gcr.return_value = ({'mock': 'gcr'}, check_dt) mock_pfr.return_value = {'mock': 'pfr'} mock_crc.return_value = True res = self.cls._get_refreshed_check_result('abc123') assert res == {'mock': 'pfr'} assert mock_gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_crc.mock_calls == [call(self.cls, 'abc123')] assert mock_pfr.mock_calls == [call(self.cls, 'abc123')] assert mock_logger.mock_calls == [ call.debug('Handling refresh of check: %s', 'abc123'), call.debug( 'ta_refresh_mode older; check last refresh: %s; ' 'threshold=%d seconds', check_dt, 120), call.info('Refreshing Trusted Advisor check: %s', 'abc123') ] @freeze_time("2016-12-16 10:40:42", tz_offset=0) def test_mode_int_within_threshold(self): self.cls.refresh_mode = 120 # 2 minutes check_dt = datetime(2016, 12, 16, hour=10, minute=40, second=12, tzinfo=utc) with patch('%s._get_check_result' % pb, autospec=True) as mock_gcr: with patch('%s._can_refresh_check' % pb, autospec=True) as mock_crc: with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s._poll_for_refresh' % pb, autospec=True) as mock_pfr: mock_gcr.return_value = ({'mock': 'gcr'}, check_dt) mock_pfr.return_value = {'mock': 'pfr'} mock_crc.return_value = True res = self.cls._get_refreshed_check_result('abc123') assert res == {'mock': 'gcr'} assert mock_gcr.mock_calls == [ call(self.cls, 'abc123'), call(self.cls, 'abc123') ] assert mock_crc.mock_calls == [call(self.cls, 'abc123')] assert mock_pfr.mock_calls == [] assert mock_logger.mock_calls == [ call.debug('Handling refresh of check: %s', 'abc123'), call.debug( 'ta_refresh_mode older; check last refresh: %s; ' 'threshold=%d seconds', check_dt, 120), call.warning( 'Trusted Advisor check %s last refresh time of %s ' 'is newer than refresh threshold of %d seconds.', 'abc123', datetime(2016, 12, 16, 10, 40, 12, tzinfo=utc), 120) ] @freeze_time("2016-12-16 10:40:42", tz_offset=0) def test_mode_trigger(self): self.cls.refresh_mode = 'trigger' check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) with patch('%s._get_check_result' % pb, autospec=True) as mock_gcr: with patch('%s._can_refresh_check' % pb, autospec=True) as mock_crc: with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s._poll_for_refresh' % pb, autospec=True) as mock_pfr: mock_gcr.return_value = ({'mock': 'gcr'}, check_dt) mock_pfr.return_value = {'mock': 'pfr'} mock_crc.return_value = True res = self.cls._get_refreshed_check_result('abc123') assert res == {'mock': 'gcr'} assert mock_gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_crc.mock_calls == [call(self.cls, 'abc123')] assert mock_pfr.mock_calls == [] assert mock_logger.mock_calls == [ call.debug('Handling refresh of check: %s', 'abc123'), call.info('Refreshing Trusted Advisor check: %s', 'abc123') ] @freeze_time("2016-12-16 10:40:42", tz_offset=0) def test_cant_refresh(self): self.cls.refresh_mode = 120 # 2 minutes check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) with patch('%s._get_check_result' % pb, autospec=True) as mock_gcr: with patch('%s._can_refresh_check' % pb, autospec=True) as mock_crc: with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s._poll_for_refresh' % pb, autospec=True) as mock_pfr: mock_gcr.return_value = ({'mock': 'gcr'}, check_dt) mock_pfr.return_value = {'mock': 'pfr'} mock_crc.return_value = False res = self.cls._get_refreshed_check_result('abc123') assert res == {'mock': 'gcr'} assert mock_gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_crc.mock_calls == [call(self.cls, 'abc123')] assert mock_pfr.mock_calls == [] assert mock_logger.mock_calls == [ call.debug('Handling refresh of check: %s', 'abc123') ]
class TestGetCheckResult(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_simple(self): tmp = self.mock_conn.describe_trusted_advisor_check_result check_result = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [{ 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }] } } tmp.return_value = check_result res = self.cls._get_check_result('abc123') assert tmp.mock_calls == [call(checkId='abc123', language='en')] assert res == (check_result, datetime(2015, 6, 15, 20, 27, 42, tzinfo=utc)) def test_no_timestamp(self): tmp = self.mock_conn.describe_trusted_advisor_check_result check_result = { 'result': { 'flaggedResources': [{ 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }] } } tmp.return_value = check_result res = self.cls._get_check_result('abc123') assert tmp.mock_calls == [call(checkId='abc123', language='en')] assert res == (check_result, None)
class TestPollForRefresh(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor({}, {}) self.cls.conn = self.mock_conn def test_no_timeout(self): self.cls.refresh_timeout = None check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) now_dt = datetime(2016, 12, 16, hour=11, minute=30, second=12, tzinfo=utc) statuses = [{ 'statuses': [{ 'status': 'none' }] }, { 'statuses': [{ 'status': 'enqueued' }] }, { 'statuses': [{ 'status': 'processing' }] }, { 'statuses': [{ 'status': 'success' }] }] m_s = self.mock_conn.describe_trusted_advisor_check_refresh_statuses with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s.sleep' % pbm, autospec=True) as mock_sleep: with patch('%s._get_check_result' % pb, autospec=True) as gcr: with patch('%s.datetime_now' % pbm) as mock_dt_now: mock_dt_now.return_value = now_dt m_s.side_effect = statuses gcr.return_value = ({'foo': 'bar'}, check_dt) res = self.cls._poll_for_refresh('abc123') assert res == {'foo': 'bar'} assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']) ] assert gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_sleep.mock_calls == [call(30), call(30), call(30)] assert mock_dt_now.mock_calls == [ call(), call(), call(), call(), call() ] assert mock_logger.mock_calls == [ call.warning('Polling for TA check %s refresh...', 'abc123'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'none'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'enqueued'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'processing'), call.debug('Checking refresh status'), call.info('Refresh status: %s; done polling', 'success'), call.info('Done polling for check refresh'), call.debug('Check shows last refresh time of: %s', check_dt) ] def test_timeout(self): self.cls.refresh_timeout = 45 check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) now_dts = [ datetime(2016, 12, 16, hour=11, minute=30, second=0, tzinfo=utc), datetime(2016, 12, 16, hour=11, minute=30, second=0, tzinfo=utc), datetime(2016, 12, 16, hour=11, minute=30, second=30, tzinfo=utc), datetime(2016, 12, 16, hour=11, minute=31, second=0, tzinfo=utc), ] status = {'statuses': [{'status': 'processing'}]} m_s = self.mock_conn.describe_trusted_advisor_check_refresh_statuses with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s.sleep' % pbm, autospec=True) as mock_sleep: with patch('%s._get_check_result' % pb, autospec=True) as gcr: with patch('%s.datetime_now' % pbm) as mock_dt_now: mock_dt_now.side_effect = now_dts m_s.return_value = status gcr.return_value = ({'foo': 'bar'}, check_dt) res = self.cls._poll_for_refresh('abc123') assert res == {'foo': 'bar'} assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']) ] assert gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_sleep.mock_calls == [call(30), call(30)] assert mock_dt_now.mock_calls == [call(), call(), call(), call()] assert mock_logger.mock_calls == [ call.warning('Polling for TA check %s refresh...', 'abc123'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'processing'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'processing'), call.error('Timed out waiting for TA Check refresh; status=%s', 'processing'), call.info('Done polling for check refresh'), call.debug('Check shows last refresh time of: %s', check_dt) ] def test_none(self): self.cls.refresh_timeout = None check_dt = datetime(2016, 12, 16, hour=10, minute=30, second=12, tzinfo=utc) now_dt = datetime(2016, 12, 16, hour=11, minute=30, second=12, tzinfo=utc) statuses = [{ 'statuses': [{ 'status': 'none' }] }, { 'statuses': [{ 'status': 'enqueued' }] }, { 'statuses': [{ 'status': 'processing' }] }, { 'statuses': [{ 'status': 'none' }] }] m_s = self.mock_conn.describe_trusted_advisor_check_refresh_statuses with patch('%s.logger' % pbm, autospec=True) as mock_logger: with patch('%s.sleep' % pbm, autospec=True) as mock_sleep: with patch('%s._get_check_result' % pb, autospec=True) as gcr: with patch('%s.datetime_now' % pbm) as mock_dt_now: mock_dt_now.return_value = now_dt m_s.side_effect = statuses gcr.return_value = ({'foo': 'bar'}, check_dt) res = self.cls._poll_for_refresh('abc123') assert res == {'foo': 'bar'} assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']), call.describe_trusted_advisor_check_refresh_statuses( checkIds=['abc123']) ] assert gcr.mock_calls == [call(self.cls, 'abc123')] assert mock_sleep.mock_calls == [call(30), call(30), call(30)] assert mock_dt_now.mock_calls == [ call(), call(), call(), call(), call() ] assert mock_logger.mock_calls == [ call.warning('Polling for TA check %s refresh...', 'abc123'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'none'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'enqueued'), call.debug('Checking refresh status'), call.info('Refresh status: %s; sleeping 30s', 'processing'), call.debug('Checking refresh status'), call.warning( 'Trusted Advisor check refresh status went ' 'from "%s" to "%s"; refresh is either complete ' 'or timed out on AWS side. Continuing', 'processing', 'none'), call.info('Done polling for check refresh'), call.debug('Check shows last refresh time of: %s', check_dt) ]
class Test_TrustedAdvisor(object): def setup(self): self.mock_conn = Mock() self.mock_client_config = Mock() type(self.mock_client_config).region_name = 'us-east-1' type(self.mock_conn)._client_config = self.mock_client_config self.cls = TrustedAdvisor() self.cls.conn = self.mock_conn self.mock_svc1 = Mock(spec_set=_AwsService) self.mock_svc2 = Mock(spec_set=_AwsService) self.services = { 'SvcFoo': self.mock_svc1, 'SvcBar': self.mock_svc2, } def test_init(self): cls = TrustedAdvisor() assert cls.conn is None assert cls.account_id is None assert cls.account_role is None assert cls.region == 'us-east-1' assert cls.ta_region is None assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None def test_init_sts(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id is None assert cls.mfa_serial_number is None assert cls.mfa_token is None def test_init_sts_external_id(self): cls = TrustedAdvisor(account_id='aid', account_role='role', region='r', external_id='myeid') assert cls.conn is None assert cls.account_id == 'aid' assert cls.account_role == 'role' assert cls.region == 'us-east-1' assert cls.ta_region == 'r' assert cls.external_id == 'myeid' assert cls.mfa_serial_number is None assert cls.mfa_token is None def test_update_limits(self): mock_results = Mock() with patch('%s.connect' % pb, autospec=True) as mock_connect: with patch('%s._poll' % pb, autospec=True) as mock_poll: with patch('%s._update_services' % pb, autospec=True) as mock_update_services: mock_poll.return_value = mock_results self.cls.update_limits(self.services) assert mock_connect.mock_calls == [call(self.cls)] assert mock_poll.mock_calls == [call(self.cls)] assert mock_update_services.mock_calls == [ call(self.cls, mock_results, self.services) ] def test_get_limit_check_id(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Service Limits', 'id': 'bar', 'metadata': [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ], }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == ('bar', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_get_limit_check_id_none(self): api_resp = { 'checks': [ { 'category': 'performance', 'name': 'Something Else', 'id': 'bar', }, { 'category': 'fault_tolerance', 'name': 'ELB Cross-Zone Load Balancing', 'id': 'foo', }, ] } self.mock_conn.describe_trusted_advisor_checks.return_value = api_resp res = self.cls._get_limit_check_id() assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] def test_get_limit_check_id_subscription_required(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'AWS Premium Support Subscription is required ' 'to use this service.', 'Code': 'SubscriptionRequiredException' } } raise ClientError(response, 'operation') assert self.cls.have_ta is True self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._get_limit_check_id() assert self.cls.have_ta is False assert res == (None, None) assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert mock_logger.mock_calls == [ call.debug("Querying Trusted Advisor checks"), call.warning( "Cannot check TrustedAdvisor: %s", 'AWS Premium Support Subscription is required to ' 'use this service.') ] def test_get_limit_check_id_other_exception(self): def se_api(language=None): response = { 'ResponseMetadata': { 'HTTPStatusCode': 400, 'RequestId': '3cc9b2a8-c6e5-11e5-bc1d-b13dcea36176' }, 'Error': { 'Message': 'foo', 'Code': 'SomeOtherException' } } raise ClientError(response, 'operation') self.mock_conn.describe_trusted_advisor_checks.side_effect = se_api with pytest.raises(ClientError) as excinfo: self.cls._get_limit_check_id() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_checks(language='en') ] assert excinfo.value.response['ResponseMetadata'][ 'HTTPStatusCode'] == 400 assert excinfo.value.response['Error']['Message'] == 'foo' assert excinfo.value.response['Error']['Code'] == 'SomeOtherException' def test_poll_id_none(self): tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = None res = self.cls._poll() assert tmp.mock_calls == [] assert res is None def test_poll(self): tmp = self.mock_conn.describe_trusted_advisor_check_result poll_return_val = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, ] } } tmp.return_value = poll_return_val with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) res = self.cls._poll() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_result(checkId='foo', language='en') ] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Launch configurations': 20, 'Auto Scaling groups': 40, } } def test_poll_region(self): tmp = self.mock_conn.describe_trusted_advisor_check_result self.cls.ta_region = 'us-west-2' poll_return_value = { 'result': { 'timestamp': '2015-06-15T20:27:42Z', 'flaggedResources': [ { 'status': 'ok', 'resourceId': 'resid1', 'isSuppressed': False, 'region': 'us-west-2', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '20', '2', 'Green' ] }, { 'status': 'ok', 'resourceId': 'resid2', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-east-1', 'AutoScaling', 'Launch configurations', '20', '18', 'Yellow' ] }, { 'status': 'ok', 'resourceId': 'resid3', 'isSuppressed': False, 'region': 'us-east-1', 'metadata': [ 'us-west-2', 'AutoScaling', 'Auto Scaling groups', '40', '10', 'Green' ] }, ] } } tmp.return_value = poll_return_value with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: mock_id.return_value = ('foo', [ 'Region', 'Service', 'Limit Name', 'Limit Amount', 'Current Usage', 'Status' ]) res = self.cls._poll() assert self.mock_conn.mock_calls == [ call.describe_trusted_advisor_check_result(checkId='foo', language='en') ] assert mock_id.mock_calls == [call(self.cls)] assert res == { 'AutoScaling': { 'Auto Scaling groups': 20, } } def test_poll_dont_have_ta(self): self.cls.have_ta = False tmp = self.mock_conn.describe_trusted_advisor_check_result with patch('%s._get_limit_check_id' % pb, autospec=True) as mock_id: with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: res = self.cls._poll() assert self.mock_conn.mock_calls == [] assert tmp.mock_calls == [] assert mock_id.mock_calls == [call(self.cls)] assert mock_logger.mock_calls == [ call.info('Beginning TrustedAdvisor poll'), call.info('TrustedAdvisor.have_ta is False; not polling TA') ] assert res == {} def test_update_services(self): def se_set(lname, val): if lname == 'blam': raise ValueError("foo") mock_autoscale = Mock(spec_set=_AwsService) mock_ec2 = Mock(spec_set=_AwsService) mock_ec2._set_ta_limit.side_effect = se_set mock_vpc = Mock(spec_set=_AwsService) services = { 'AutoScaling': mock_autoscale, 'EC2': mock_ec2, 'VPC': mock_vpc, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, 'blam': 10, }, 'OtherService': { 'blarg': 1, }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': 11, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls._update_services(ta_results, services) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info( "TrustedAdvisor returned check results for unknown " "limit '%s' (service %s)", 'blam', 'EC2'), call.info( "TrustedAdvisor returned check results for unknown " "service '%s'", 'OtherService'), call.info("Done updating TA limits on all services"), ] assert mock_autoscale.mock_calls == [ call._set_ta_limit('bar', 40), call._set_ta_limit('foo', 20), ] assert mock_ec2.mock_calls == [ call._set_ta_limit('baz', 5), call._set_ta_limit('blam', 10), call._set_ta_limit('VPC Elastic IP addresses (EIPs)', 11) ] def test_update_services_no_ec2(self): mock_autoscale = Mock(spec_set=_AwsService) mock_vpc = Mock(spec_set=_AwsService) services = { 'AutoScaling': mock_autoscale, 'VPC': mock_vpc, } ta_results = { 'AutoScaling': { 'foo': 20, 'bar': 40, }, 'EC2': { 'baz': 5, }, 'VPC': { 'VPC Elastic IP addresses (EIPs)': 11, } } with patch('awslimitchecker.trustedadvisor' '.logger', autospec=True) as mock_logger: self.cls._update_services(ta_results, services) assert mock_logger.mock_calls == [ call.debug("Updating TA limits on all services"), call.info( "TrustedAdvisor returned check results for unknown " "service '%s'", 'EC2'), call.info("Done updating TA limits on all services"), ] assert mock_autoscale.mock_calls == [ call._set_ta_limit('bar', 40), call._set_ta_limit('foo', 20), ] assert mock_vpc.mock_calls == []