def test_ent_cert_no_product(self):
self.ent_dir = StubCertificateDirectory(
[StubEntitlementCertificate(None, provided_products=[],
quantity=2)])
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 42})
self.sorter = CertSorter(self.prod_dir, self.ent_dir,
stub_facts.get_facts())
self.assertEqual(0, len(self.sorter.partially_valid_products))
def test_simple_full_stack_0_sockets(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
# System has 1 sockets:
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 1})
# 0 sockets is basically "unlimited" sockets
# see bz#805415
ent_dir = StubCertificateDirectory([
stub_ent_cert(INST_PID_5, [INST_PID_1], stack_id=STACK_1, sockets=0)])
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
self.assertTrue(INST_PID_1 in sorter.valid_products)
self.assertFalse(INST_PID_1 in sorter.partially_valid_products)
self.assertFalse(INST_PID_1 in sorter.unentitled_products)
def test_simple_partial_stack(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
# System has 8 sockets:
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 8})
# Only 2 sockets covered:
ent_dir = StubCertificateDirectory([
stub_ent_cert(INST_PID_5, [INST_PID_1], stack_id=STACK_1, sockets=2)])
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
self.assertFalse(INST_PID_1 in sorter.unentitled_products)
self.assertFalse(INST_PID_1 in sorter.valid_products)
self.assertTrue(INST_PID_1 in sorter.partially_valid_products)
self.assertEquals(1, len(sorter.partially_valid_products))
self.assertEquals(1, len(sorter.partially_valid_products[INST_PID_1]))
def test_simple_full_stack_singlecert_with_quantity(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
# System has 8 sockets:
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 8})
# 1 ent cert providing 4 sockets with quantity 2 means we're valid:
ent_dir = StubCertificateDirectory([
stub_ent_cert(INST_PID_5, [INST_PID_1], stack_id=STACK_1,
sockets=4, quantity=2)])
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
self.assertFalse(INST_PID_1 in sorter.unentitled_products)
self.assertTrue(INST_PID_1 in sorter.valid_products)
self.assertFalse(INST_PID_1 in sorter.partially_valid_products)
self.assertEquals(0, len(sorter.partially_valid_products))
def test_non_stacked_lacking_sockets(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
# System has 8 sockets:
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 8})
# Only 2 sockets covered by a non-stacked entitlement:
ent_dir = StubCertificateDirectory(
[stub_ent_cert(INST_PID_5, [INST_PID_1], sockets=2, quantity=5)])
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
self.assertFalse(INST_PID_1 in sorter.unentitled_products)
self.assertFalse(INST_PID_1 in sorter.valid_products)
self.assertTrue(INST_PID_1 in sorter.partially_valid_products)
self.assertEquals(1, len(sorter.partially_valid_products))
self.assertEquals(1, len(sorter.partially_valid_products[INST_PID_1]))
def test_non_stacked_lacking_sockets(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
# System has 8 sockets:
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 8})
# Only 2 sockets covered by a non-stacked entitlement:
ent_dir = StubCertificateDirectory([
stub_ent_cert(INST_PID_5, [INST_PID_1], sockets=2,
quantity=5)])
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
self.assertFalse(INST_PID_1 in sorter.unentitled_products)
self.assertFalse(INST_PID_1 in sorter.valid_products)
self.assertTrue(INST_PID_1 in sorter.partially_valid_products)
self.assertEquals(1, len(sorter.partially_valid_products))
self.assertEquals(1, len(sorter.partially_valid_products[INST_PID_1]))
def test_is_not_vert_when_fact_is_defined_as_empty(self):
fact_dict = {
QuantityDefaultValueCalculator._VIRT_IS_GUEST_FACT_NAME: ""
}
facts = StubFacts(fact_dict, facts_changed=False)
calculator = QuantityDefaultValueCalculator(facts, [])
self.assertFalse(calculator._is_virtual_machine())
def test_partial_stack_for_uninstalled_products(self):
# No products installed:
prod_dir = StubCertificateDirectory([])
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 42})
ents = []
ents.append(
stub_ent_cert(INST_PID_5, ['prod1'], stack_id=STACK_1, quantity=2))
ent_dir = StubCertificateDirectory(ents)
sorter = CertSorter(prod_dir, ent_dir, stub_facts.get_facts())
# No installed products, so nothing should show up as partially valid:
self.assertEquals(0, len(sorter.partially_valid_products))
self.assertEquals(1, len(sorter.partial_stacks))
self.assertTrue(STACK_1 in sorter.partial_stacks)
self.assertFalse(sorter.is_valid())
def test_partial_stack_for_uninstalled_products(self):
# No products installed:
prod_dir = StubCertificateDirectory([])
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 42})
ents = []
ents.append(stub_ent_cert(INST_PID_5, ['prod1'],
stack_id=STACK_1, quantity=2))
ent_dir = StubCertificateDirectory(ents)
sorter = CertSorter(prod_dir, ent_dir,
stub_facts.get_facts())
# No installed products, so nothing should show up as partially valid:
self.assertEquals(0, len(sorter.partially_valid_products))
self.assertEquals(1, len(sorter.partial_stacks))
self.assertTrue(STACK_1 in sorter.partial_stacks)
self.assertFalse(sorter.is_valid())
def test_partial_stack_different_first_product(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 4})
ents = []
ents.append(stub_ent_cert(INST_PID_5, [INST_PID_1],
stack_id=STACK_1, sockets=1))
ents.append(stub_ent_cert(INST_PID_6, [INST_PID_1],
stack_id=STACK_1, sockets=1))
ent_dir = StubCertificateDirectory(ents)
sorter = CertSorter(prod_dir, ent_dir,
stub_facts.get_facts())
# Installed product should show up as partially valid:
self.assertEquals(1, len(sorter.partially_valid_products))
self.assertTrue(INST_PID_1 in sorter.partially_valid_products)
self.assertFalse(INST_PID_1 in sorter.valid_products)
self.assertTrue(STACK_1 in sorter.partial_stacks)
def __init__(self):
self.parent_window = Mock()
self.backend = StubBackend()
self.async = Mock()
self.reg_info = Mock()
self.expected_facts = {'fact1': 'one',
'fact2': 'two',
'system': '',
'system.uuid': 'MOCKUUID'}
self.facts = StubFacts(fact_dict=self.expected_facts)
def setUp(self):
super(FactDialogTests, self).setUp()
expected_facts = {'fact1': 'one',
'fact2': 'two',
'system': 'Unknown',
'system.uuid': 'MOCKUUID'}
self.expected_facts = expected_facts
self.stub_facts = StubFacts(expected_facts)
def setUp(self):
self.backend = StubBackend()
self.consumer = Mock()
expected_facts = {
'fact1': 'one',
'fact2': 'two',
'system': '',
'system.uuid': 'MOCKUUID'
}
self.facts = StubFacts(fact_dict=expected_facts)
self.rs = RegisterScreen(self.backend, self.consumer, self.facts)
def test_valid_stack_different_first_products(self):
prod_dir = StubCertificateDirectory([stub_prod_cert(INST_PID_1)])
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 4})
# Two entitlements, same stack, different first products, each
# providing 2 sockets: (should be valid)
ents = []
ents.append(stub_ent_cert(INST_PID_5, [INST_PID_1],
stack_id=STACK_1, sockets=2))
ents.append(stub_ent_cert(INST_PID_6, [INST_PID_1],
stack_id=STACK_1, sockets=2))
ent_dir = StubCertificateDirectory(ents)
sorter = CertSorter(prod_dir, ent_dir,
stub_facts.get_facts())
# Installed product should show up as valid:
self.assertEquals(1, len(sorter.valid_products))
self.assertTrue(INST_PID_1 in sorter.valid_products)
self.assertEquals(0, len(sorter.partially_valid_products))
self.assertEquals(0, len(sorter.partial_stacks))
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 setUp(self):
self.uep = StubUEP
self.backend = StubBackend()
self.consumer = Mock()
self.facts = StubFacts({})
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10",
stacking_id=None)
self.cert_dir = StubCertificateDirectory([self.cert1])
def setUp(self):
expected_facts = {'fact1': 'one',
'fact2': 'two',
'system': 'Unknown',
'system.uuid': 'MOCKUUID'}
self.expected_facts = expected_facts
self.stub_facts = StubFacts(expected_facts)
self.uep = StubUEP()
self.consumer = Mock()
self.consumer.uuid = "MOCKUUID"
self.consumer.name = "MOCK CONSUMER"
sys.stderr = MockStderr
sys.stdout = MockStdout
def setUp(self):
super(RegisterScreenTests, self).setUp()
self.backend = StubBackend()
expected_facts = {
'fact1': 'one',
'fact2': 'two',
'system': '',
'system.uuid': 'MOCKUUID'
}
self.facts = StubFacts(fact_dict=expected_facts)
self.rs = RegisterScreen(self.backend, self.facts)
self.rs._screens[CHOOSE_SERVER_PAGE] = Mock()
self.rs._screens[CHOOSE_SERVER_PAGE].index = 0
self.rs._screens[CHOOSE_SERVER_PAGE].button_label = "Dummy"
self.rs._screens[CHOOSE_SERVER_PAGE].apply.return_value = \
CREDENTIALS_PAGE
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 setUp(self):
expected_facts = {
'fact1': 'one',
'fact2': 'two',
'system': 'Unknown',
'system.uuid': 'MOCKUUID'
}
self.expected_facts = expected_facts
self.stub_facts = StubFacts(expected_facts)
self.backend = StubBackend()
id_mock = Mock()
id_mock.name = 'system'
id_mock.uuid = 'Random UUID'
id_mock.exists_and_valid = Mock(return_value=True)
provide(IDENTITY, id_mock)
sys.stderr = MockStderr
sys.stdout = MockStdout
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)
def test_get_total_consumed_adds_matched(self):
calculator = QuantityDefaultValueCalculator(StubFacts({}),
entitlements)
self.assertEquals(5, calculator._get_total_consumed(product_id_1))
def create_cert_sorter(product_certs, entitlement_certs, machine_sockets=8):
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": machine_sockets})
return CertSorter(StubCertificateDirectory(product_certs),
StubEntitlementDirectory(entitlement_certs),
stub_facts.get_facts())
def create_cert_sorter(product_certs, entitlement_certs, machine_sockets=8):
stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": machine_sockets})
return CertSorter(StubCertificateDirectory(product_certs),
StubEntitlementDirectory(entitlement_certs),
stub_facts.get_facts())
def test_total_consumed_does_not_include_future_entitlements(self):
calculator = QuantityDefaultValueCalculator(StubFacts({}),
entitlements)
self.assertEquals(9, calculator._get_total_consumed(product_id_2))
def test_is_not_vert_when_fact_is_not_defined(self):
facts = StubFacts({}, facts_changed=False)
calculator = QuantityDefaultValueCalculator(facts, [])
self.assertFalse(calculator._is_virtual_machine())
def test_get_total_consumed_returns_zero_when_no_matches(self):
calculator = QuantityDefaultValueCalculator(StubFacts({}),
entitlements)
self.assertEquals(0, calculator._get_total_consumed("does-not-match"))
