def test_03_delete_orphans(self):
     delete_response = Orphans.delete(self.pulp)
     self.assertPulpOK()
     Task.wait_for_report(self.pulp, delete_response)
     info = Orphans.info(self.pulp)
     orphans = Orphans.get(self.pulp)
     self.assertPulpOK()
     for orphan_type_name in info.keys():
         self.assertEqual(len(orphans[orphan_type_name]), info[orphan_type_name]['count'])
         self.assertEqual(orphans[orphan_type_name], [])

 def test_01_orphan_info_data_integrity(self):
     info = Orphans.info(self.pulp)
     orphans = Orphans.get(self.pulp)
     self.assertPulpOK()
     for orphan_type_name in orphans.keys():
         # reported count info is the same as the orphans counted
         self.assertEqual(len(orphans[orphan_type_name]), info[orphan_type_name]['count'])
         orphan_type = UnitFactory.type_map.orphans[orphan_type_name]
         # '_href' is correct
         self.assertEqual(pulp_auto.path_join(pulp_auto.path, orphan_type.path), info[orphan_type_name]['_href'])
         # all orphans are of the same type
         for orphan in orphans[orphan_type_name]:
             self.assertTrue(isinstance(orphan, orphan_type), "different type: %s, %s" % (orphan_type_name, orphan.type_id))

 def test_02_delete_single_orphan(self):
     old_info = Orphans.info(self.pulp)
     rpm_orphans = RpmOrphan.list(self.pulp)
     assert rpm_orphans, "No orphans found; there might be other 'Zoo' repos in %s" % self.pulp
     rpm_orphans[0].delete(self.pulp)
     del rpm_orphans[0]
     self.assertPulpOK()
     new_info = Orphans.info(self.pulp)
     self.assertEqual(old_info['rpm']['count'], new_info['rpm']['count'] + 1)
     self.assertEqual(
         sorted(map(lambda x: x.data['name'], rpm_orphans)),
         sorted(map(lambda x: x.data['name'], RpmOrphan.list(self.pulp)))
     )

 def tearDownClass(cls):
     for repo_id in ['SimpleRepoCopyTest_repo', 'SimpleRepoCopyTest_copy', 'SimpleRepoCopyTest_copy1']:
         Repo({'id': repo_id}).delete(cls.pulp)
     #orphans also should be deleted in cleanup
     delete_response = Orphans.delete(cls.pulp)
     delete_task = Task.from_response(delete_response)
     delete_task.wait(cls.pulp)

 def tearDownClass(cls):
     with \
         cls.pulp.asserting(True), \
         cls.agent.catching(False), \
         cls.agent.running(cls.qpid_handle, frequency=10) \
     :
         Task.wait_for_report(cls.pulp, cls.repo.delete(cls.pulp))
         Task.wait_for_report(cls.pulp, Orphans.delete(cls.pulp))
         cls.consumer.delete(cls.pulp)
     super(ConsumerAgentPulpTest, cls).tearDownClass()

 def test_10_check_orphan_appears(self):
     # unasosciate same module that was unassocited in dest_repo1
     response = self.dest_repo2.unassociate_units(
         self.pulp, data={"criteria": {"type_ids": ["puppet_module"], "filters": {"unit": {"name": "tomcat7_rhel"}}}}
     )
     self.assertPulp(code=202)
     Task.wait_for_report(self.pulp, response)
     # check 1 orphan appeared
     orphan_info = Orphans.info(self.pulp)
     self.assertEqual(orphan_info["puppet_module"]["count"], 1)

 def test_09_check_orphan_appears(self):
     #delete source repo
     self.source_repo.delete(self.pulp)
     self.assertPulpOK()
     #unasosciate same module that was unassocited in dest_repo1
     response = self.dest_repo2.unassociate_units(
         self.pulp,
         data={"criteria": {"type_ids": ["iso"], "filters": {"unit": {"name": "test.iso"}}}}
     )
     self.assertPulp(code=202)
     Task.wait_for_report(self.pulp, response)
     #check 1 orphan appeared
     orphan_info = Orphans.info(self.pulp)
     self.assertEqual(orphan_info['iso']['count'], 1)

    def tearDownClass(cls):
        # delete repo
        with cls.pulp.asserting(True):
            response = cls.repo.delete(cls.pulp)
        Task.wait_for_report(cls.pulp, response)
        
        # delete orphans
        with cls.pulp.asserting(True):
            response = Orphans.delete(cls.pulp)
        Task.wait_for_report(cls.pulp, response)

        # unregister consumer
        cls.consumer.cli.unregister()
        super(RegRepoNoFeedTest, cls).tearDownClass()

    def tearDownClass(cls):
        with cls.pulp.asserting(True):
            response = cls.repo1.delete(cls.pulp)
        Task.wait_for_report(cls.pulp, response)

        with cls.pulp.asserting(True):
            response = cls.repo2.delete(cls.pulp)
        Task.wait_for_report(cls.pulp, response)

        # delete orphans
        with cls.pulp.asserting(True):
            response = Orphans.delete(cls.pulp)
        Task.wait_for_report(cls.pulp, response)

        super(PackageCategoryTest, cls).tearDownClass()

 def test_09_check_orphan_appears(self):
     #delete source repo
     self.source_repo.delete(self.pulp)
     self.assertPulpOK()
     #unasosciate same module that was unassocited in dest_repo1
     response = self.dest_repo2.unassociate_units(
         self.pulp,
         data={"criteria": {"type_ids": ["puppet_module"], "filters": {"unit": {"name": "tomcat7_rhel"}}}}
     )
     self.assertPulp(code=202)
     task = Task.from_response(response)
     task.wait(self.pulp)
     #check 1 orphan appeared
     orphan_info = Orphans.info(self.pulp)
     self.assertEqual(orphan_info['puppet_module']['count'], 1)

 def test_10_delete_orphans(self):
     delete_response = Orphans.delete(self.pulp)
     self.assertPulpOK()
     Task.wait_for_report(self.pulp, delete_response)

 def test_06_delete_orphan_by_type_and_id_1092467(self):
     # https://bugzilla.redhat.com/show_bug.cgi?id=1092467
     response = Orphans.delete_by_type_id(self.pulp, data=[{'content_type_id': 'rpm', 'unit_id': 'd0dc2044-1edc-4298-bf10-a472ea943fe1'}]
                                         )
     self.assertPulpOK()
     Task.wait_for_report(self.pulp, response)

 def test_07_delete_orphans(self):
     response = Orphans.delete(self.pulp)
     task = Task.from_response(response)
     task.wait(self.pulp)

 def test_07_delete_orphans(self):
     response = Orphans.delete(self.pulp)
     Task.wait_for_report(self.pulp, response)

 def test_00_get_orphan_info(self):
     Orphans.info(self.pulp)
     self.assertPulpOK()

 def test_13_check_deleted_orphans(self):
     # check that all puppet_module orphans were successfully deleted
     orphans = Orphans.get(self.pulp)
     self.assertEqual(orphans['iso'], [])
     orphan_info = Orphans.info(self.pulp)
     self.assertEqual(orphan_info['iso']['count'], 0)

 def test_08_check_no_orphan_appeared(self):
     #check that after unassociation of module it did not appered among orphans as it is still referenced to other repo
     orphans = Orphans.get(self.pulp)
     self.assertEqual(orphans['iso'], [])
     orphan_info = Orphans.info(self.pulp)
     self.assertEqual(orphan_info['iso']['count'], 0)

 def test_00_view_all_orphaned_content(self):
     Orphans.info(self.pulp)
     self.assertPulpOK()

 def test_10_delete_orphans(self):
     delete_response = Orphans.delete(self.pulp)
     self.assertPulpOK()
     task = Task.from_response(delete_response)
     task.wait(self.pulp)

 def test_01_view_orphaned_content_by_type(self):
     rpm_orphans = RpmOrphan.list(self.pulp)
     self.assertPulpOK()
     all_orphans = Orphans.info(self.pulp)
     self.assertEqual(len(rpm_orphans), all_orphans['rpm']['count'])