def test_filter_overlap_sorter_without_valid(self): product1 = "Test Product 1" provided1 = "Provided By Test Product 1" product2 = "Test Product 2" provided2 = "Provided By Test Product 2" cert_start = datetime.now() - timedelta(days=10) cert_end = datetime.now() + timedelta(days=365) cert1 = StubProductCertificate(StubProduct(provided1), start_date=cert_start, end_date=cert_end) ent_dir = StubCertificateDirectory([cert1]) mock_sorter = Mock() mock_sorter.valid_products = {} pool_filter = PoolFilter(product_dir=StubCertificateDirectory([]), entitlement_dir=ent_dir, sorter=mock_sorter) pools = [ create_pool(product1, product1, provided_products=[provided1], start_end_range=DateRange(cert_start, cert_end)), create_pool(product2, product2, provided_products=[provided2], start_end_range=DateRange(cert_start, cert_end)) ] result = pool_filter.filter_out_overlapping(pools) self.assertEquals([pools[0], pools[1]], result) result = pool_filter.filter_out_non_overlapping(pools) self.assertEquals([], result)
def test_installed_filter_direct_match(self): product1 = "product1" product2 = "product2" pd = StubCertificateDirectory([StubProductCertificate(StubProduct(product2))]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [create_pool(product1, product1), create_pool(product1, product1), create_pool(product2, product2)] result = pool_filter.filter_out_installed(pools) self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]["productId"])
def test_filter_product_name(self): product1 = "Foo Product" product2 = "Bar Product" pd = StubCertificateDirectory([]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [create_pool(product1, product1), create_pool(product2, product2)] result = pool_filter.filter_product_name(pools, "Foo") self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]["productId"])
def test_filter_product_name(self): product1 = 'Foo Product' product2 = 'Bar Product' pd = StubCertificateDirectory([]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [ create_pool(product1, product1), create_pool(product2, product2), ] result = pool_filter.filter_product_name(pools, "Foo") self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]['productId'])
def test_filter_no_overlap_with_future_entitlement(self): product1 = "Test Product 1" provided1 = "Provided By Test Product 1" cert_start = datetime.now() + timedelta(days=365) cert_end = cert_start + timedelta(days=365) cert1 = StubProductCertificate(StubProduct(provided1), start_date=cert_start, end_date=cert_end) ent_dir = StubCertificateDirectory([cert1]) pool_filter = PoolFilter(product_dir=StubCertificateDirectory([]), entitlement_dir=ent_dir) begin_date = datetime.now() - timedelta(days=100) end_date = datetime.now() + timedelta(days=100) pools = [ create_pool(product1, product1, provided_products=[provided1], start_end_range=DateRange(begin_date, end_date)), ] result = pool_filter.filter_out_overlapping(pools) self.assertEquals(1, len(result)) result = pool_filter.filter_out_non_overlapping(pools) self.assertEquals(0, len(result))
def test_single_pool(self): product = "product1" pools = [create_pool(product, product, quantity=10, consumed=5)] results = merge_pools(pools) self.assertEquals(1, len(results.values())) result = results.values()[0] self.assertEquals(product, result.product_id)
def test_single_pool(self): product = 'product1' pools = [create_pool(product, product, quantity=10, consumed=5)] results = merge_pools(pools) self.assertEquals(1, len(results.values())) result = results.values()[0] self.assertEquals(product, result.product_id)
def test_installed_filter_provided_match(self): product1 = 'product1' product2 = 'product2' provided = 'providedProduct' pd = StubCertificateDirectory([ StubProductCertificate(StubProduct(provided))]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [ create_pool(product1, product1), create_pool(product2, product2, provided_products=[provided]), ] result = pool_filter.filter_out_installed(pools) self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]['productId'])
def _create_wrapper(self, add_is_virt_only=False, is_virt_only_value="true", add_stacking_id=False, stacking_id=None, pool_type=None, add_management_enabled=False, management_enabled_value="true"): attrs = {} if add_is_virt_only: attrs['virt_only'] = is_virt_only_value prod_attrs = {} if add_stacking_id: prod_attrs['stacking_id'] = stacking_id if add_management_enabled: prod_attrs['management_enabled'] = management_enabled_value calculatedAttributes = None if pool_type: calculatedAttributes = {'compliance_type': pool_type} pool = create_pool("pid", "pname", attributes=create_attribute_list(attrs), productAttributes=create_attribute_list(prod_attrs), calculatedAttributes=calculatedAttributes) return PoolWrapper(pool)
def test_installed_filter_provided_match(self): product1 = 'product1' product2 = 'product2' provided = 'providedProduct' pd = StubCertificateDirectory( [StubProductCertificate(StubProduct(provided))]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [ create_pool(product1, product1), create_pool(product2, product2, provided_products=[provided]), ] result = pool_filter.filter_out_installed(pools) self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]['productId'])
def _create_pool(self, product_id, product_name, stacking_id=None): prod_attrs = [] if stacking_id: stacking_id_attribute = { "name": "stacking_id", "value": stacking_id } prod_attrs.append(stacking_id_attribute) return create_pool(product_id, product_name, productAttributes=prod_attrs)
def test_if_not_multi_entitled_defualt_to_1(self): fact_dict = {QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '1'} facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed pool = create_pool("my-test-product", "My Test Product") qty = calculator.calculate(pool) self.assertEquals(1, qty)
def test_filter_product_name_matches_provided(self): product1 = 'Foo Product' product2 = 'Bar Product' pd = StubCertificateDirectory([]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) pools = [ create_pool(product1, product1, provided_products=[product2]), ] result = pool_filter.filter_product_name(pools, "Bar") self.assertEquals(1, len(result)) self.assertEquals(product1, result[0]['productId'])
def test_autobind_load_provided_products(self): self.stub_product = stubs.StubProduct("some_random_product") self.stub_pool = modelhelpers.create_pool(product_id=self.stub_product.getHash(), product_name=self.stub_product.getName(), provided_products=['rhel-6']) self.stub_backend.uep.stub_pool = self.stub_pool self.stub_installed_product = stubs.StubProduct("rhel-6") self.stub_backend.product_dir = stubs.StubCertificateDirectory([stubs.StubProductCertificate(self.stub_installed_product)]) autobind_controller = self._get_autobind_controller() autobind_controller.load() self.assertTrue('Pro' in autobind_controller.suitable_slas)
def _create_wrapper(self, add_is_virt_only=False, is_virt_only_value="true", add_stacking_id=False, stacking_id=None): attrs = {} if add_is_virt_only: attrs['virt_only'] = is_virt_only_value prod_attrs = {} if add_stacking_id: prod_attrs['stacking_id'] = stacking_id pool = create_pool("pid", "pname", attributes=create_attribute_list(attrs), productAttributes=create_attribute_list(prod_attrs)) return PoolWrapper(pool)
def test_if_not_multi_entitled_defualt_to_1(self): fact_dict = { QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '1' } facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed pool = create_pool("my-test-product", "My Test Product") qty = calculator.calculate(pool) self.assertEquals(1, qty)
def test_multiple_pools(self): product1 = 'product1' product2 = 'product2' pools = [ create_pool(product1, product1, quantity=10, consumed=5), create_pool(product1, product1, quantity=55, consumed=20), create_pool(product2, product2, quantity=10, consumed=5), ] results = merge_pools(pools) self.assertEquals(2, len(results.values())) self.assertTrue(product1 in results) self.assertTrue(product2 in results) # Check product1: merged_pools = results[product1] self.assertEquals(product1, merged_pools.product_id) self.assertEquals(65, merged_pools.quantity) self.assertEquals(25, merged_pools.consumed) # Check product2: merged_pools = results[product2] self.assertEquals(product2, merged_pools.product_id) self.assertEquals(10, merged_pools.quantity) self.assertEquals(5, merged_pools.consumed)
def test_autobind_load_provided_products(self): self.stub_product = stubs.StubProduct("some_random_product") self.stub_pool = modelhelpers.create_pool( product_id=self.stub_product.getHash(), product_name=self.stub_product.getName(), provided_products=['rhel-6']) self.stub_backend.uep.stub_pool = self.stub_pool self.stub_installed_product = stubs.StubProduct("rhel-6") self.stub_backend.product_dir = stubs.StubCertificateDirectory( [stubs.StubProductCertificate(self.stub_installed_product)]) autobind_controller = self._get_autobind_controller() autobind_controller.load() self.assertTrue('Pro' in autobind_controller.suitable_slas)
def setUp(self): self.stub_backend = stubs.StubBackend() self.stub_consumer = stubs.StubConsumer() self.stub_facts = stubs.StubFacts() self.stub_backend.uep.getConsumer = self._getConsumerData self.stub_product = stubs.StubProduct("rhel-6") self.stub_pool = modelhelpers.create_pool(product_id=self.stub_product.getHash(), product_name=self.stub_product.getName()) self.stub_backend.uep.stub_pool = self.stub_pool self.stub_backend.product_dir = stubs.StubCertificateDirectory([stubs.StubProductCertificate(self.stub_product)]) self.stub_backend.entitlement_dir = stubs.StubEntitlementDirectory([]) self.stub_backend.uep.dryRunBind = self._dryRunBind
def test_on_virtual_machine_default_uses_1_if_vcpu_and_sockets_do_not_exist_on_product(self): fact_dict = {QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: True, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4', QuantityDefaultValueCalculator._CPUS_FACT_NAME: '8'} facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed self.assertTrue(calculator._is_virtual_machine()) productAttrs = [create_attr("multi-entitlement", "yes")] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) self.assertEquals(1, qty)
def test_calculated_value_is_zero_when_negative_value_is_calculated(self): fact_dict = {QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4'} facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = ten_consumed self.assertFalse(calculator._is_virtual_machine()) productAttrs = [create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._SOCKETS_PROD_ATTR_NAME, "2")] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # 10 are already consumed, so 4/2 - 10 = -8 self.assertEquals(0, qty)
def test_on_virtual_machine_currently_consumed_is_factored_into_default_calculation(self): fact_dict = {QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: True, QuantityDefaultValueCalculator._CPUS_FACT_NAME: '4'} facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = two_consumed self.assertTrue(calculator._is_virtual_machine()) productAttrs = [create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._CPUS_PROD_ATTR_NAME, "1")] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # ceil(m_cpus / p_cpus) - consumed self.assertEquals(2, qty)
def test_on_pysical_machine_default_to_num_sockets_by_socket_count(self): fact_dict = {QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4'} facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed self.assertFalse(calculator._is_virtual_machine()) productAttrs = [create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._SOCKETS_PROD_ATTR_NAME, "2")] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # ceil(m_sockets / p_socket) self.assertEquals(2, qty)
def _create_wrapper(self, add_is_virt_only=False, is_virt_only_value="true", add_stacking_id=False, stacking_id=None, pool_type=None): attrs = {} if add_is_virt_only: attrs['virt_only'] = is_virt_only_value prod_attrs = {} if add_stacking_id: prod_attrs['stacking_id'] = stacking_id calculatedAttributes = None if pool_type: calculatedAttributes = {'compliance_type': pool_type} pool = create_pool("pid", "pname", attributes=create_attribute_list(attrs), productAttributes=create_attribute_list(prod_attrs), calculatedAttributes=calculatedAttributes) return PoolWrapper(pool)
def setUp(self): self.stub_backend = stubs.StubBackend() self.stub_consumer = stubs.StubConsumer() self.stub_facts = stubs.StubFacts() self.stub_backend.uep.getConsumer = self._getConsumerData self.stub_product = stubs.StubProduct("rhel-6") self.stub_pool = modelhelpers.create_pool( product_id=self.stub_product.getHash(), product_name=self.stub_product.getName()) self.stub_backend.uep.stub_pool = self.stub_pool self.stub_backend.product_dir = stubs.StubCertificateDirectory( [stubs.StubProductCertificate(self.stub_product)]) self.stub_backend.entitlement_dir = stubs.StubEntitlementDirectory([]) self.stub_backend.uep.dryRunBind = self._dryRunBind
def test_filter_no_overlap(self): product1 = "Test Product 1" provided1 = "Provided By Test Product 1" pd = StubCertificateDirectory([]) pool_filter = PoolFilter(product_dir=pd, entitlement_dir=StubCertificateDirectory([])) begin_date = datetime.now() - timedelta(days=10) end_date = datetime.now() + timedelta(days=365) pools = [ create_pool(product1, product1, provided_products=[provided1], start_end_range=DateRange(begin_date, end_date)), ] result = pool_filter.filter_out_overlapping(pools) self.assertEquals(1, len(result)) result = pool_filter.filter_out_non_overlapping(pools) self.assertEquals(0, len(result))
def test_on_virtual_machine_default_uses_1_if_vcpu_and_sockets_do_not_exist_on_product( self): fact_dict = { QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: True, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4', QuantityDefaultValueCalculator._CPUS_FACT_NAME: '8' } facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed self.assertTrue(calculator._is_virtual_machine()) productAttrs = [create_attr("multi-entitlement", "yes")] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) self.assertEquals(1, qty)
def test_on_pysical_machine_default_to_num_sockets_by_socket_count(self): fact_dict = { QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4' } facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed self.assertFalse(calculator._is_virtual_machine()) productAttrs = [ create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._SOCKETS_PROD_ATTR_NAME, "2") ] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # ceil(m_sockets / p_socket) self.assertEquals(2, qty)
def test_on_virt_machine_default_rounds_up(self): fact_dict = { QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: True, QuantityDefaultValueCalculator._CPUS_FACT_NAME: '8' } facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = zero_consumed self.assertTrue(calculator._is_virtual_machine()) productAttrs = [ create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._CPUS_PROD_ATTR_NAME, "6") ] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # ceil(m_cpus / p_cpus) self.assertEquals(2, qty)
def test_calculated_value_is_zero_when_negative_value_is_calculated(self): fact_dict = { QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: False, QuantityDefaultValueCalculator._SOCKET_FACT_NAME: '4' } facts = StubFacts(fact_dict, facts_changed=False) calculator = QuantityDefaultValueCalculator(facts, []) calculator._get_total_consumed = ten_consumed self.assertFalse(calculator._is_virtual_machine()) productAttrs = [ create_attr("multi-entitlement", "yes"), create_attr(QuantityDefaultValueCalculator._SOCKETS_PROD_ATTR_NAME, "2") ] pool = create_pool("my-test-product", "My Test Product", productAttributes=productAttrs) qty = calculator.calculate(pool) # 10 are already consumed, so 4/2 - 10 = -8 self.assertEquals(0, qty)