示例#1
0
 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'
示例#2
0
 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'
示例#3
0
    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')
        ]
示例#4
0
    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'
            )
        ]
示例#5
0
 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
示例#6
0
    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'
            )
        ]
示例#7
0
    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')
        ]
示例#8
0
 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
示例#9
0
 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 == []
示例#10
0
 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 == []
示例#11
0
 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 == []
示例#12
0
 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 == []
示例#13
0
 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'
示例#14
0
 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 == []
示例#15
0
 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 == []
示例#16
0
    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'
            )
        ]
示例#17
0
    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'
            )
        ]
示例#18
0
 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
示例#19
0
 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
示例#20
0
 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)]
示例#21
0
 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)]
示例#22
0
 def test_required_iam_permissions(self):
     cls = _EbsService(21, 43)
     assert cls.required_iam_permissions() == [
         "ec2:DescribeVolumes",
         "ec2:DescribeSnapshots"
     ]
示例#23
0
    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)]
示例#24
0
 def test_required_iam_permissions(self):
     cls = _EbsService(21, 43)
     assert cls.required_iam_permissions() == [
         "ec2:DescribeVolumes",
         "ec2:DescribeSnapshots"
     ]
示例#25
0
    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)
        ]