def test_get_limits(self): """test some things all limits should conform to""" cls = _EbsService(21, 43) limits = cls.get_limits() for x in limits: assert isinstance(limits[x], AwsLimit) assert x == limits[x].name assert limits[x].service == cls assert len(limits) == 6 piops = limits['Provisioned IOPS'] assert piops.limit_type == 'AWS::EC2::Volume' assert piops.limit_subtype == 'io1' assert piops.default_limit == 40000 piops_tb = limits['Provisioned IOPS (SSD) storage (GiB)'] assert piops_tb.limit_type == 'AWS::EC2::Volume' assert piops_tb.limit_subtype == 'io1' assert piops_tb.default_limit == 20480 gp_tb = limits['General Purpose (SSD) volume storage (GiB)'] assert gp_tb.limit_type == 'AWS::EC2::Volume' assert gp_tb.limit_subtype == 'gp2' assert gp_tb.default_limit == 20480 mag_tb = limits['Magnetic volume storage (GiB)'] assert mag_tb.limit_type == 'AWS::EC2::Volume' assert mag_tb.limit_subtype == 'standard' assert mag_tb.default_limit == 20480 act_snaps = limits['Active snapshots'] assert act_snaps.limit_type == 'AWS::EC2::VolumeSnapshot' act_vols = limits['Active volumes'] assert act_vols.limit_type == 'AWS::EC2::Volume'
def test_find_usage_snapshots(self): mock_snap1 = Mock(spec_set=Snapshot) type(mock_snap1).id = 'snap-1' mock_snap2 = Mock(spec_set=Snapshot) type(mock_snap2).id = 'snap-2' mock_snap3 = Mock(spec_set=Snapshot) type(mock_snap3).id = 'snap-3' mock_conn = Mock(spec_set=EC2Connection) return_value = [ mock_snap1, mock_snap2, mock_snap3, ] cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ebs.logger') as mock_logger: with patch('%s.boto_query_wrapper' % self.pbm) as mock_wrapper: mock_wrapper.return_value = return_value cls._find_usage_snapshots() assert mock_logger.mock_calls == [ call.debug("Getting usage for EBS snapshots"), ] assert len(cls.limits['Active snapshots'].get_current_usage()) == 1 assert cls.limits['Active snapshots' ''].get_current_usage()[0].get_value() == 3 assert mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(mock_conn.get_all_snapshots, owner='self') ]
def test_find_usage_snapshots(self): response = result_fixtures.EBS.test_find_usage_snapshots mock_conn = Mock() cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ebs.logger') as mock_logger: with patch('%s.paginate_dict' % self.pbm) as mock_paginate: mock_paginate.return_value = response cls._find_usage_snapshots() assert mock_logger.mock_calls == [ call.debug("Getting usage for EBS snapshots"), ] assert len(cls.limits['Active snapshots'].get_current_usage()) == 1 assert cls.limits['Active snapshots' ''].get_current_usage()[0].get_value() == 3 assert mock_conn.mock_calls == [] assert mock_paginate.mock_calls == [ call( mock_conn.describe_snapshots, OwnerIds=['self'], alc_marker_path=['NextToken'], alc_data_path=['Snapshots'], alc_marker_param='NextToken' ) ]
def test_init(self): """test __init__()""" cls = _EbsService(21, 43) assert cls.service_name == 'EBS' assert cls.conn is None assert cls.warning_threshold == 21 assert cls.critical_threshold == 43
def test_get_limits_again(self): """test that existing limits dict is returned on subsequent calls""" cls = _EbsService(21, 43) cls.limits = {'foo': 'bar'} with patch('%s._get_limits_ebs' % self.pb) as mock_ebs: res = cls.get_limits() assert res == {'foo': 'bar'} assert mock_ebs.mock_calls == []
def test_connect(self): """test connect()""" mock_conn = Mock() cls = _EbsService(21, 43) with patch('awslimitchecker.services.ec2.boto.connect_ec2') as mock_ec2: mock_ec2.return_value = mock_conn cls.connect() assert mock_ec2.mock_calls == [call()] assert mock_conn.mock_calls == []
def test_connect_again(self): """make sure we re-use the connection""" mock_conn = Mock() cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ec2.boto.connect_ec2') as mock_ec2: mock_ec2.return_value = mock_conn cls.connect() assert mock_ec2.mock_calls == [] assert mock_conn.mock_calls == []
def test_get_limits(self): """test some things all limits should conform to""" cls = _EbsService(21, 43, {}, None) limits = cls.get_limits() for x in limits: assert isinstance(limits[x], AwsLimit) assert x == limits[x].name assert limits[x].service == cls assert len(limits) == 11 piops_io1 = limits['Provisioned IOPS (io1)'] assert piops_io1.limit_type == 'AWS::EC2::Volume' assert piops_io1.limit_subtype == 'io1' assert piops_io1.default_limit == 300000 piops_io1_tb = limits['Provisioned IOPS SSD (io1) storage (GiB)'] assert piops_io1_tb.limit_type == 'AWS::EC2::Volume' assert piops_io1_tb.limit_subtype == 'io1' assert piops_io1_tb.default_limit == 307200 piops_io2 = limits['Provisioned IOPS (io2)'] assert piops_io2.limit_type == 'AWS::EC2::Volume' assert piops_io2.limit_subtype == 'io2' assert piops_io2.default_limit == 100000 piops_io2_tb = limits['Provisioned IOPS SSD (io2) storage (GiB)'] assert piops_io2_tb.limit_type == 'AWS::EC2::Volume' assert piops_io2_tb.limit_subtype == 'io2' assert piops_io2_tb.default_limit == 20480 gp2_tb = limits['General Purpose (SSD gp2) volume storage (GiB)'] assert gp2_tb.limit_type == 'AWS::EC2::Volume' assert gp2_tb.limit_subtype == 'gp2' assert gp2_tb.default_limit == 307200 assert gp2_tb.ta_limit_name == 'General Purpose SSD (gp2) ' \ 'volume storage (GiB)' gp3_tb = limits['General Purpose (SSD gp3) volume storage (GiB)'] assert gp3_tb.limit_type == 'AWS::EC2::Volume' assert gp3_tb.limit_subtype == 'gp3' assert gp3_tb.default_limit == 307200 assert gp3_tb.ta_limit_name == 'General Purpose SSD (gp3) ' \ 'volume storage (GiB)' mag_tb = limits['Magnetic volume storage (GiB)'] assert mag_tb.limit_type == 'AWS::EC2::Volume' assert mag_tb.limit_subtype == 'standard' assert mag_tb.default_limit == 307200 assert mag_tb.ta_limit_name == 'Magnetic (standard) volume ' \ 'storage (GiB)' st_tb = limits['Throughput Optimized (HDD) volume storage (GiB)'] assert st_tb.limit_type == 'AWS::EC2::Volume' assert st_tb.limit_subtype == 'st1' assert st_tb.default_limit == 307200 sc_tb = limits['Cold (HDD) volume storage (GiB)'] assert sc_tb.limit_type == 'AWS::EC2::Volume' assert sc_tb.limit_subtype == 'sc1' assert sc_tb.default_limit == 307200 act_snaps = limits['Active snapshots'] assert act_snaps.limit_type == 'AWS::EC2::VolumeSnapshot' act_vols = limits['Active volumes'] assert act_vols.limit_type == 'AWS::EC2::Volume'
def test_connect_again(self): """make sure we re-use the connection""" mock_conn = Mock() cls = _EbsService(21, 43) cls.conn = mock_conn with patch('%s.boto.connect_ec2' % self.pbm) as mock_ec2: with patch('%s.connect_via' % self.pb) as mock_connect_via: mock_ec2.return_value = mock_conn cls.connect() assert mock_ec2.mock_calls == [] assert mock_conn.mock_calls == [] assert mock_connect_via.mock_calls == []
def test_find_usage_ebs(self): response = result_fixtures.EBS.test_find_usage_ebs mock_conn = Mock() cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ebs.logger') as mock_logger: with patch('%s.paginate_dict' % self.pbm) as mock_paginate: mock_paginate.return_value = response cls._find_usage_ebs() assert mock_logger.mock_calls == [ call.debug("Getting usage for EBS volumes"), call.error( "ERROR - unknown volume type '%s' for volume " "%s; not counting", 'othertype', 'vol-7') ] assert len(cls.limits['Provisioned IOPS'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS' ''].get_current_usage()[0].get_value() == 1000 assert len(cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()[0].get_value() == 500 assert len(cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 45 assert len(cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 508 assert len(cls.limits['Throughput Optimized (HDD) volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Throughput Optimized (HDD) volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 500 assert len(cls.limits['Cold (HDD) volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Cold (HDD) volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 1000 assert len(cls.limits['Active volumes'].get_current_usage()) == 1 assert cls.limits['Active volumes' ''].get_current_usage()[0].get_value() == 9 assert mock_conn.mock_calls == [] assert mock_paginate.mock_calls == [ call( mock_conn.describe_volumes, alc_marker_path=['NextToken'], alc_data_path=['Volumes'], alc_marker_param='NextToken' ) ]
def test_connect_region(self): """test connect()""" mock_conn = Mock() mock_conn_via = Mock() cls = _EbsService(21, 43, region='foo') with patch('%s.boto.connect_ec2' % self.pbm) as mock_ec2: with patch('%s.connect_via' % self.pb) as mock_connect_via: mock_ec2.return_value = mock_conn mock_connect_via.return_value = mock_conn_via cls.connect() assert mock_ec2.mock_calls == [] assert mock_conn.mock_calls == [] assert mock_connect_via.mock_calls == [call(connect_to_region)] assert cls.conn == mock_conn_via
def test_find_usage(self): with patch.multiple( self.pb, connect=DEFAULT, _find_usage_ebs=DEFAULT, _find_usage_snapshots=DEFAULT, autospec=True, ) as mocks: cls = _EbsService(21, 43) assert cls._have_usage is False cls.find_usage() assert cls._have_usage is True assert len(mocks) == 3 for m in mocks: assert mocks[m].mock_calls == [call(cls)]
def test_required_iam_permissions(self): cls = _EbsService(21, 43) assert cls.required_iam_permissions() == [ "ec2:DescribeVolumes", "ec2:DescribeSnapshots" ]
def test_find_usage_ebs(self): # 500G magnetic mock_vol1 = Mock(spec_set=Volume) type(mock_vol1).id = 'vol-1' type(mock_vol1).type = 'standard' # magnetic type(mock_vol1).size = 500 type(mock_vol1).iops = None # 8G magnetic mock_vol2 = Mock(spec_set=Volume) type(mock_vol2).id = 'vol-2' type(mock_vol2).type = 'standard' # magnetic type(mock_vol2).size = 8 type(mock_vol2).iops = None # 15G general purpose SSD, 45 IOPS mock_vol3 = Mock(spec_set=Volume) type(mock_vol3).id = 'vol-3' type(mock_vol3).type = 'gp2' type(mock_vol3).size = 15 type(mock_vol3).iops = 45 # 30G general purpose SSD, 90 IOPS mock_vol4 = Mock(spec_set=Volume) type(mock_vol4).id = 'vol-4' type(mock_vol4).type = 'gp2' type(mock_vol4).size = 30 type(mock_vol4).iops = 90 # 400G PIOPS, 700 IOPS mock_vol5 = Mock(spec_set=Volume) type(mock_vol5).id = 'vol-5' type(mock_vol5).type = 'io1' type(mock_vol5).size = 400 type(mock_vol5).iops = 700 # 100G PIOPS, 300 IOPS mock_vol6 = Mock(spec_set=Volume) type(mock_vol6).id = 'vol-6' type(mock_vol6).type = 'io1' type(mock_vol6).size = 100 type(mock_vol6).iops = 300 mock_vol7 = Mock(spec_set=Volume) type(mock_vol7).id = 'vol-7' type(mock_vol7).type = 'othertype' mock_conn = Mock(spec_set=EC2Connection) return_value = [ mock_vol1, mock_vol2, mock_vol3, mock_vol4, mock_vol5, mock_vol6, mock_vol7 ] cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ebs.logger') as mock_logger: with patch('%s.boto_query_wrapper' % self.pbm) as mock_wrapper: mock_wrapper.return_value = return_value cls._find_usage_ebs() assert mock_logger.mock_calls == [ call.debug("Getting usage for EBS volumes"), call.error( "ERROR - unknown volume type '%s' for volume " "%s; not counting", 'othertype', 'vol-7') ] assert len(cls.limits['Provisioned IOPS'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS' ''].get_current_usage()[0].get_value() == 1000 assert len(cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()[0].get_value() == 500 assert len(cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 45 assert len(cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 508 assert len(cls.limits['Active volumes'].get_current_usage()) == 1 assert cls.limits['Active volumes' ''].get_current_usage()[0].get_value() == 7 assert mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [call(mock_conn.get_all_volumes)]
def test_find_usage_ebs(self): # 500G magnetic mock_vol1 = Mock(spec_set=Volume) type(mock_vol1).id = 'vol-1' type(mock_vol1).type = 'standard' # magnetic type(mock_vol1).size = 500 type(mock_vol1).iops = None # 8G magnetic mock_vol2 = Mock(spec_set=Volume) type(mock_vol2).id = 'vol-2' type(mock_vol2).type = 'standard' # magnetic type(mock_vol2).size = 8 type(mock_vol2).iops = None # 15G general purpose SSD, 45 IOPS mock_vol3 = Mock(spec_set=Volume) type(mock_vol3).id = 'vol-3' type(mock_vol3).type = 'gp2' type(mock_vol3).size = 15 type(mock_vol3).iops = 45 # 30G general purpose SSD, 90 IOPS mock_vol4 = Mock(spec_set=Volume) type(mock_vol4).id = 'vol-4' type(mock_vol4).type = 'gp2' type(mock_vol4).size = 30 type(mock_vol4).iops = 90 # 400G PIOPS, 700 IOPS mock_vol5 = Mock(spec_set=Volume) type(mock_vol5).id = 'vol-5' type(mock_vol5).type = 'io1' type(mock_vol5).size = 400 type(mock_vol5).iops = 700 # 100G PIOPS, 300 IOPS mock_vol6 = Mock(spec_set=Volume) type(mock_vol6).id = 'vol-6' type(mock_vol6).type = 'io1' type(mock_vol6).size = 100 type(mock_vol6).iops = 300 mock_vol7 = Mock(spec_set=Volume) type(mock_vol7).id = 'vol-7' type(mock_vol7).type = 'othertype' mock_conn = Mock(spec_set=EC2Connection) return_value = [ mock_vol1, mock_vol2, mock_vol3, mock_vol4, mock_vol5, mock_vol6, mock_vol7 ] cls = _EbsService(21, 43) cls.conn = mock_conn with patch('awslimitchecker.services.ebs.logger') as mock_logger: with patch('%s.boto_query_wrapper' % self.pbm) as mock_wrapper: mock_wrapper.return_value = return_value cls._find_usage_ebs() assert mock_logger.mock_calls == [ call.debug("Getting usage for EBS volumes"), call.error( "ERROR - unknown volume type '%s' for volume " "%s; not counting", 'othertype', 'vol-7') ] assert len(cls.limits['Provisioned IOPS'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS' ''].get_current_usage()[0].get_value() == 1000 assert len(cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Provisioned IOPS (SSD) storage ' '(GiB)'].get_current_usage()[0].get_value() == 500 assert len(cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['General Purpose (SSD) volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 45 assert len(cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()) == 1 assert cls.limits['Magnetic volume storage ' '(GiB)'].get_current_usage()[0].get_value() == 508 assert len(cls.limits['Active volumes'].get_current_usage()) == 1 assert cls.limits['Active volumes' ''].get_current_usage()[0].get_value() == 7 assert mock_conn.mock_calls == [] assert mock_wrapper.mock_calls == [ call(mock_conn.get_all_volumes) ]