def test_unsubscribe_unregistered(self):
        connection.UEPConnection = StubUEP

        prod = StubProduct('stub_product')
        ent = StubEntitlementCertificate(prod)

        cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
            [ent]),
                                            prod_dir=StubProductDirectory([]))

        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
        StubConsumerIdentity.exists = classmethod(lambda cls: False)

        cmd.main(['unsubscribe', '--all'])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent.is_deleted)

        prod = StubProduct('stub_product')
        ent1 = StubEntitlementCertificate(prod)
        ent2 = StubEntitlementCertificate(prod)

        cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
            [ent1, ent2]),
                                            prod_dir=StubProductDirectory([]))
        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
        StubConsumerIdentity.exists = classmethod(lambda cls: False)

        cmd.main(['unsubscribe', '--serial=%s' % ent1.serial])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent1.is_deleted)
        self.assertFalse(ent2.is_deleted)
Exemple #2
0
    def test_unsubscribe_unregistered(self):
        prod = StubProduct('stub_product')
        ent = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.RemoveCommand()

        self._inject_mock_invalid_consumer()

        cmd.main(['remove', '--all'])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent.is_deleted)

        prod = StubProduct('stub_product')
        ent1 = StubEntitlementCertificate(prod)
        ent2 = StubEntitlementCertificate(prod)
        ent3 = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.RemoveCommand()

        cmd.main([
            'remove',
            '--serial=%s' % ent1.serial,
            '--serial=%s' % ent3.serial
        ])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent1.is_deleted)
        self.assertFalse(ent2.is_deleted)
        self.assertTrue(ent3.is_deleted)
    def setUp(self):
        # Setup mock product and entitlement certs:
        self.prod_dir = StubCertificateDirectory([
            # Will be unentitled:
            StubProductCertificate(StubProduct(INST_PID_1)),
            # Will be entitled:
            StubProductCertificate(StubProduct(INST_PID_2)),
            # Will be entitled but expired:
            StubProductCertificate(StubProduct(INST_PID_3)),
        ])

        self.ent_dir = StubEntitlementDirectory([
            StubEntitlementCertificate(StubProduct(INST_PID_2)),
            StubEntitlementCertificate(
                StubProduct(INST_PID_3),
                start_date=datetime.now() - timedelta(days=365),
                end_date=datetime.now() - timedelta(days=2)),
            StubEntitlementCertificate(
                StubProduct(INST_PID_4),
                start_date=datetime.now() - timedelta(days=365),
                end_date=datetime.now() + timedelta(days=365)),
            StubEntitlementCertificate(StubProduct(INST_PID_5)),
            # entitled, but not installed
            StubEntitlementCertificate(StubProduct('not_installed_product')),
        ])
 def setUp(self):
     super(TestPoolTypeCache, self).setUp()
     self.cp_provider = inj.require(inj.CP_PROVIDER)
     self.cp_provider.consumer_auth_cp = Mock()
     self.cp = self.cp_provider.consumer_auth_cp
     certs = [StubEntitlementCertificate(StubProduct('pid1'), pool=StubPool('someid'))]
     self.ent_dir = StubEntitlementDirectory(certificates=certs)
Exemple #5
0
    def test_scan_for_expired_or_future_products(self):
        prod_dir = StubProductDirectory(pids=["a", "b", "c", "d", "e"])
        ent_dir = StubEntitlementDirectory([
            StubEntitlementCertificate(StubProduct("a")),
            StubEntitlementCertificate(StubProduct("b")),
            StubEntitlementCertificate(StubProduct("c")),
            StubEntitlementCertificate(
                StubProduct("d"),
                start_date=datetime.now() - timedelta(days=365),
                end_date=datetime.now() - timedelta(days=2)),
            StubEntitlementCertificate(
                StubProduct("e"),
                start_date=datetime.now() + timedelta(days=365),
                end_date=datetime.now() + timedelta(days=730)),
        ])

        inj.provide(inj.PROD_DIR, prod_dir)
        inj.provide(inj.ENT_DIR, ent_dir)

        sorter = StubCertSorter()
        sorter.valid_products = {"a": StubProduct("a")}
        sorter.partially_valid_products = {"b": StubProduct("b")}

        sorter._scan_entitlement_certs()

        self.assertEquals(["d"], sorter.expired_products.keys())
        self.assertEquals(["e"], sorter.future_products.keys())

        self.assertEquals(3, len(sorter.valid_entitlement_certs))
Exemple #6
0
    def test_expired_are_not_ignored_when_installing_certs(self, write_mock):
        valid_ent = StubEntitlementCertificate(StubProduct("PValid"))
        expired_ent = StubEntitlementCertificate(
            StubProduct("PExpired"),
            start_date=datetime.now() - timedelta(days=365),
            end_date=datetime.now() - timedelta(days=10))

        cp_certificates = [valid_ent, expired_ent]

        mock_uep = Mock()
        mock_uep.getCertificates.return_value = cp_certificates  # Passed into build(cert)

        update_action = TestingUpdateAction(mock_uep,
                                            StubEntitlementDirectory([]))
        report = UpdateReport()
        report.expected.append(valid_ent.serial)
        report.expected.append(expired_ent.serial)

        exceptions = update_action.install(
            [valid_ent.serial, expired_ent.serial], report)
        self.assertEqual(0, len(exceptions),
                         "No exceptions should have been thrown")
        self.assertTrue(valid_ent in report.added)
        self.assertTrue(valid_ent.serial in report.expected)
        self.assertTrue(expired_ent.serial in report.expected)
Exemple #7
0
    def setUp(self, mock_update):
        SubManFixture.setUp(self)
        # Setup mock product and entitlement certs:
        self.prod_dir = StubProductDirectory(
            pids=[INST_PID_1, INST_PID_2, INST_PID_3, INST_PID_4])
        self.ent_dir = StubEntitlementDirectory([
            StubEntitlementCertificate(PROD_2, ent_id=ENT_ID_2),
            StubEntitlementCertificate(PROD_1, ent_id=ENT_ID_1),
            StubEntitlementCertificate(product=PROD_4,
                                       stacking_id=STACK_1,
                                       ent_id=ENT_ID_4),
            # entitled, but not installed
            StubEntitlementCertificate(StubProduct('not_installed_product',
                                                   name="Some Product"),
                                       ent_id="SomeSubId"),
        ])

        self.mock_uep = StubUEP()

        self.status_mgr = EntitlementStatusCache()
        self.status_mgr.load_status = Mock(return_value=SAMPLE_COMPLIANCE_JSON)
        self.status_mgr.write_cache = Mock()
        inj.provide(inj.ENTITLEMENT_STATUS_CACHE, self.status_mgr)
        inj.provide(inj.PROD_DIR, self.prod_dir)
        inj.provide(inj.ENT_DIR, self.ent_dir)
        self.sorter = CertSorter()
        self.sorter.is_registered = Mock(return_value=True)
Exemple #8
0
    def _stub_content(self, include_content_access=False):
        stub_prod = StubProduct('stub_product', provided_tags="stub-product")

        stub_content = StubContent("a_test_repo", required_tags="stub-product")

        stub_content2 = StubContent("test_repo_2",
                                    required_tags="stub-product")

        stub_ent_cert = StubEntitlementCertificate(stub_prod,
                                                   content=[stub_content])
        stub_prod_cert = StubProductCertificate(stub_prod)

        certs = [stub_ent_cert]
        if include_content_access:
            self.stub_content_access_cert = StubEntitlementCertificate(
                stub_prod,
                content=[stub_content, stub_content2],
                entitlement_type=CONTENT_ACCESS_CERT_TYPE)
            # content access cert is first and last, so naively wrong implementations will prioritize it.
            certs = [
                self.stub_content_access_cert, stub_ent_cert,
                self.stub_content_access_cert
            ]
        stub_ent_dir = StubEntitlementDirectory(certs)
        stub_prod_dir = StubProductDirectory([stub_prod_cert])

        inj.provide(inj.ENT_DIR, stub_ent_dir)
        inj.provide(inj.PROD_DIR, stub_prod_dir)
    def test_unsubscribe_registered(self):
        prod = StubProduct('stub_product')
        ent1 = StubEntitlementCertificate(prod)
        ent2 = StubEntitlementCertificate(prod)
        ent3 = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.UnSubscribeCommand()

        mock_identity = self._inject_mock_valid_consumer()
        managercli.EntCertActionInvoker = StubEntActionInvoker

        cmd.main(['unsubscribe', '--all'])
        self.assertEquals(cmd.cp.called_unbind_uuid, mock_identity.uuid)

        cmd.main(['unsubscribe', '--serial=%s' % ent1.serial])
        self.assertEquals(cmd.cp.called_unbind_serial, ['%s' % ent1.serial])

        code = cmd.main([
            'unsubscribe',
            '--serial=%s' % ent2.serial,
            '--serial=%s' % ent3.serial
        ])
        self.assertEquals(
            cmd.cp.called_unbind_serial,
            ['%s' % ent2.serial, '%s' % ent3.serial])
        self.assertEquals(code, 0)

        self.stub_cp_provider.get_consumer_auth_cp(
        ).unbindBySerial = mock.Mock(side_effect=connection.RestlibException(
            "Entitlement Certificate with serial number "
            "2300922701043065601 could not be found."))
        code = cmd.main(['unsubscribe', '--serial=%s' % '2300922701043065601'])
Exemple #10
0
    def setUp(self):
        super(RepoUpdateActionTests, self).setUp()
        stub_prod = StubProduct("fauxprod", provided_tags="TAG1,TAG2")
        stub_prod2 = StubProduct("fauxprovidedprod", provided_tags="TAG4")
        stub_prod_cert = StubProductCertificate(stub_prod,
                                                provided_products=[stub_prod2])
        stub_prod2 = StubProduct("fauxprod2", provided_tags="TAG5,TAG6")
        stub_prod2_cert = StubProductCertificate(stub_prod2)
        prod_dir = StubProductDirectory([stub_prod_cert, stub_prod2_cert])
        inj.provide(inj.PROD_DIR, prod_dir)

        stub_content = [
            StubContent("c1", required_tags="", gpg=None),  # no required tags
            StubContent("c2", required_tags="TAG1", gpg=""),
            StubContent("c3",
                        required_tags="TAG1,TAG2,TAG3"),  # should get skipped
            StubContent("c4",
                        required_tags="TAG1,TAG2,TAG4,TAG5,TAG6",
                        gpg="/gpg.key",
                        url="/$some/$path"),
            StubContent("c5", content_type="file", required_tags="", gpg=None),
            StubContent("c6", content_type="file", required_tags="", gpg=None),
        ]
        self.stub_ent_cert = StubEntitlementCertificate(stub_prod,
                                                        content=stub_content)
        ent_dir = StubEntitlementDirectory([self.stub_ent_cert])
        inj.provide(inj.ENT_DIR, ent_dir)

        repolib.ConsumerIdentity = StubConsumerIdentity
 def test_print_consumed_no_ents(self):
     ent_dir = StubEntitlementDirectory([])
     try:
         self.cc.print_consumed(ent_dir)
         self.fail("Should have exited.")
     except SystemExit:
         pass
 def test_print_consumed_prints_nothing_with_no_service_level_match(self):
     ent_dir = StubEntitlementDirectory([self.cert_with_service_level])
     try:
         self.cc.print_consumed(ent_dir, service_level="NotFound")
         self.fail("Should have exited since an entitlement with the " + \
                   "specified service level does not exist.")
     except SystemExit:
         pass
 def setUp(self):
     self.fact_cache_dir = tempfile.mkdtemp()
     fact_cache = self.fact_cache_dir + "/facts.json"
     fd = open(fact_cache, "w")
     fd.write(facts_buf)
     fd.close()
     self.f = facts.Facts(ent_dir=StubEntitlementDirectory([]),
                          prod_dir=StubProductDirectory([]))
     self.f.CACHE_FILE = fact_cache
    def test_unsubscribe_unregistered(self):
        connection.UEPConnection = StubUEP

        prod = StubProduct('stub_product')
        ent = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.UnSubscribeCommand()

        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
        StubConsumerIdentity.exists = classmethod(lambda cls: False)

        cmd.main(['unsubscribe', '--all'])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent.is_deleted)

        prod = StubProduct('stub_product')
        ent1 = StubEntitlementCertificate(prod)
        ent2 = StubEntitlementCertificate(prod)
        ent3 = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.UnSubscribeCommand()
        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
        StubConsumerIdentity.exists = classmethod(lambda cls: False)

        code = cmd.main([
            'unsubscribe',
            '--serial=%s' % ent1.serial,
            '--serial=%s' % ent3.serial
        ])
        self.assertTrue(cmd.entitlement_dir.list_called)
        self.assertTrue(ent1.is_deleted)
        self.assertFalse(ent2.is_deleted)
        self.assertTrue(ent3.is_deleted)
        self.assertEquals(code, 0)

        code = cmd.main(['unsubscribe', '--serial=%s' % '33333333'])
        self.assertEquals(code, 1)
Exemple #15
0
    def setUp(self):
        self.cc = self.command_class(ent_dir=StubEntitlementDirectory([]),
                                     prod_dir=StubProductDirectory([]))
        # neuter the _do_command, since this is mostly
        # for testing arg parsing
        self.cc._do_command = self._do_command
        self.cc.assert_should_be_registered = self._asert_should_be_registered

        # stub out uep
        managercli.connection.UEPConnection = self._uep_connection
        sys.stdout = MockStdout()
        sys.stderr = MockStderr()
Exemple #16
0
    def _stub_content(self):
        stub_prod = StubProduct('stub_product', provided_tags="stub-product")

        stub_content = StubContent("a_test_repo", required_tags="stub-product")

        stub_ent_cert = StubEntitlementCertificate(stub_prod,
                                                   content=[stub_content])
        stub_prod_cert = StubProductCertificate(stub_prod)

        stub_ent_dir = StubEntitlementDirectory([stub_ent_cert])
        stub_prod_dir = StubProductDirectory([stub_prod_cert])

        inj.provide(inj.ENT_DIR, stub_ent_dir)
        inj.provide(inj.PROD_DIR, stub_prod_dir)
Exemple #17
0
 def test_delete(self):
     ent = StubEntitlementCertificate(StubProduct("Prod"))
     ent.delete = Mock(side_effect=OSError("Cert has already been deleted"))
     mock_uep = Mock()
     mock_uep.getCertificates = Mock(return_value=[])
     mock_uep.getCertificateSerials = Mock(return_value=[])
     update_action = TestingUpdateAction(mock_uep,
                                         StubEntitlementDirectory([ent]))
     try:
         updates, exceptions = update_action.perform()
     except OSError:
         self.fail("operation failed when certificate wasn't deleted")
     self.assertEquals(0, updates)
     self.assertEquals([], exceptions)
    def test_unsubscribe_registered(self):
        connection.UEPConnection = StubUEP

        cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
            []),
                                            prod_dir=StubProductDirectory([]))

        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: True)
        StubConsumerIdentity.exists = classmethod(lambda cls: True)
        managercli.CertLib = StubCertLib

        cmd.main(['unsubscribe', '--all'])
        self.assertEquals(cmd.cp.called_unbind_uuid,
                          StubConsumerIdentity.CONSUMER_ID)

        serial = '123456'
        cmd.main(['unsubscribe', '--serial=%s' % serial])
        self.assertEquals(cmd.cp.called_unbind_serial, serial)
Exemple #19
0
    def test_installed_products_cache_written(self):
        connection.UEPConnection = StubUEP

        cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
                              prod_dir=StubProductDirectory([]))
        cmd._persist_identity_cert = self.stub_persist
        ConsumerIdentity.exists = classmethod(lambda cls: False)

        # Mock out facts and installed products:
        cmd.facts.get_facts = Mock(return_value={
            'fact1': 'val1',
            'fact2': 'val2'
        })
        cmd.facts.write_cache = Mock()
        cmd.installed_mgr.write_cache = Mock()

        cmd.main(['register', '--username=testuser1', '--password=password'])

        self.assertEquals(1, cmd.installed_mgr.write_cache.call_count)
Exemple #20
0
    def test_register_persists_consumer_cert(self):
        connection.UEPConnection = StubUEP

        # When
        cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
                              prod_dir=StubProductDirectory([]))

        ConsumerIdentity.exists = classmethod(lambda cls: False)
        cmd._persist_identity_cert = self.stub_persist
        cmd.facts.get_facts = Mock(return_value={
            'fact1': 'val1',
            'fact2': 'val2'
        })
        cmd.facts.write_cache = Mock()
        cmd.installed_mgr.write_cache = Mock()

        cmd.main(['register', '--username=testuser1', '--password=password'])

        # Then
        self.assertEqual('dummy-consumer-uuid',
                         self.persisted_consumer["uuid"])
    def test_unsubscribe_registered(self):
        connection.UEPConnection = StubUEP

        prod = StubProduct('stub_product')
        ent1 = StubEntitlementCertificate(prod)
        ent2 = StubEntitlementCertificate(prod)
        ent3 = StubEntitlementCertificate(prod)

        inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3]))
        inj.provide(inj.PROD_DIR, StubProductDirectory([]))
        cmd = managercli.UnSubscribeCommand()

        managercli.ConsumerIdentity = StubConsumerIdentity
        StubConsumerIdentity.existsAndValid = classmethod(lambda cls: True)
        StubConsumerIdentity.exists = classmethod(lambda cls: True)
        managercli.CertLib = StubCertLib

        cmd.main(['unsubscribe', '--all'])
        self.assertEquals(cmd.cp.called_unbind_uuid,
                          StubConsumerIdentity.CONSUMER_ID)

        cmd.main(['unsubscribe', '--serial=%s' % ent1.serial])
        self.assertEquals(cmd.cp.called_unbind_serial, ['%s' % ent1.serial])

        code = cmd.main([
            'unsubscribe',
            '--serial=%s' % ent2.serial,
            '--serial=%s' % ent3.serial
        ])
        self.assertEquals(
            cmd.cp.called_unbind_serial,
            ['%s' % ent2.serial, '%s' % ent3.serial])
        self.assertEquals(code, 0)

        connection.UEPConnection.unbindBySerial = mock.Mock(
            side_effect=connection.RestlibException(
                "Entitlement Certificate with serial number 2300922701043065601 could not be found."
            ))
        code = cmd.main(['unsubscribe', '--serial=%s' % '2300922701043065601'])
        self.assertEquals(code, 1)
    def test_delete(self):
        ent = StubEntitlementCertificate(StubProduct("Prod"))
        ent.delete = Mock(side_effect=OSError("Cert has already been deleted"))
        mock_uep = Mock()
        mock_uep.getCertificates = Mock(return_value=[])
        mock_uep.getCertificateSerials = Mock(return_value=[])

        self.set_consumer_auth_cp(mock_uep)
        stub_ent_dir = StubEntitlementDirectory([ent])
        inj.provide(inj.ENT_DIR, stub_ent_dir)

        # use the injected mock uep
        update_action = TestingUpdateAction()

        try:
            update_report = update_action.perform()
        except OSError:
            self.fail("operation failed when certificate wasn't deleted")
        self.assertEquals(0, update_report.updates())

        exceptions = update_action.report.exceptions()
        self.assertEquals([], exceptions)
    def test_expired_are_not_ignored_when_installing_certs(self, write_mock, build_cert_mock):
        valid_ent = StubEntitlementCertificate(StubProduct("PValid"))
        expired_ent = StubEntitlementCertificate(StubProduct("PExpired"),
                start_date=datetime.now() - timedelta(days=365),
                end_date=datetime.now() - timedelta(days=10))

        cp_certificates = [valid_ent, expired_ent]
        # get certificates actually returns cert bundles
        cp_bundles = [{'key': Mock(), 'cert': x} for x in cp_certificates]

        # so we dont try to build actual x509 objects from stub certs
        def mock_build_cert(bundle):
            return (bundle['key'], bundle['cert'])

        build_cert_mock.side_effect = mock_build_cert

        mock_uep = Mock()
        mock_uep.getCertificateSerials.return_value = [x.serial for x in cp_certificates]
        mock_uep.getCertificates.return_value = cp_bundles  # Passed into build_cert(bundle)
        self.set_consumer_auth_cp(mock_uep)

        stub_ent_dir = StubEntitlementDirectory([])
        inj.provide(inj.ENT_DIR, stub_ent_dir)
        update_action = TestingUpdateAction()
        # we skip getting the expected serials, where this is normally
        # populated
        update_action.report.expected.append(valid_ent.serial)
        update_action.report.expected.append(expired_ent.serial)

        update_action.install([valid_ent.serial, expired_ent.serial])
        update_report = update_action.report

        self.assertEqual(0, len(update_report.exceptions()), "No exceptions should have been thrown")
        self.assertTrue(valid_ent in update_report.added)
        self.assertTrue(valid_ent.serial in update_report.expected)
        self.assertTrue(expired_ent.serial in update_report.expected)
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_print_consumed_one_ent_one_product(self):
     product = StubProduct("product1")
     ent_dir = StubEntitlementDirectory(
         [StubEntitlementCertificate(product)])
     self.cc.print_consumed(ent_dir)
 def test_print_consumed_one_ent_no_product(self):
     ent_dir = StubEntitlementDirectory(
         [StubEntitlementCertificate(product=None)])
     self.cc.print_consumed(ent_dir)
 def test_print_consumed_prints_enitlement_with_service_level_match(self):
     ent_dir = StubEntitlementDirectory([self.cert_with_service_level])
     self.cc.print_consumed(ent_dir, service_level="Premium")