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_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_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 _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_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_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 _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_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_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_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)
