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_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_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]))
Ejemplo n.º 5
0
    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]))
Ejemplo n.º 7
0
    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)
Ejemplo n.º 10
0
    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))
Ejemplo n.º 11
0
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())
Ejemplo n.º 12
0
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())