Imported Debian patch 4.0.5-6~numeezy

ipatests/test_integration/base.py

@@ -19,29 +19,72 @@
 
 """Base class for FreeIPA integration tests"""
 
-import pytest
+import nose
 
 from ipapython.ipa_log_manager import log_mgr
+from ipatests.test_integration.config import get_global_config
 from ipatests.test_integration import tasks
-from pytest_sourceorder import ordered
+from ipatests.order_plugin import ordered
 
 log = log_mgr.get_logger(__name__)
 
 
 @ordered
-@pytest.mark.usefixtures('mh')
-@pytest.mark.usefixtures('integration_logs')
 class IntegrationTest(object):
     num_replicas = 0
     num_clients = 0
     num_ad_domains = 0
     required_extra_roles = []
     topology = None
-    domain_level = None
 
     @classmethod
     def setup_class(cls):
-        pass
+
+        def get_resources(resource_container, resource_str, num_needed):
+            if len(resource_container) < num_needed:
+                raise nose.SkipTest(
+                    'Not enough %s available (have %s, need %s)' %
+                    (resource_str, len(resource_container), num_needed))
+            return resource_container[:num_needed]
+
+        config = get_global_config()
+        if not config.domains:
+            raise nose.SkipTest('Integration testing not configured')
+
+        cls.logs_to_collect = {}
+
+        cls.domain = config.domains[0]
+
+        # Check that we have enough resources available
+        cls.master = cls.domain.master
+        cls.replicas = get_resources(cls.domain.replicas, 'replicas',
+                                     cls.num_replicas)
+        cls.clients = get_resources(cls.domain.clients, 'clients',
+                                    cls.num_clients)
+        cls.ad_domains = get_resources(config.ad_domains, 'AD domains',
+                                       cls.num_ad_domains)
+
+        # Check that we have all required extra hosts at our disposal
+        available_extra_roles = [role for domain in cls.get_domains()
+                                        for role in domain.extra_roles]
+        missing_extra_roles = list(set(cls.required_extra_roles) -
+                                     set(available_extra_roles))
+
+        if missing_extra_roles:
+            raise nose.SkipTest("Not all required extra hosts available, "
+                                "missing: %s, available: %s"
+                                % (missing_extra_roles,
+                                   available_extra_roles))
+
+        for host in cls.get_all_hosts():
+            host.add_log_collector(cls.collect_log)
+            cls.prepare_host(host)
+
+        try:
+            cls.install()
+        except:
+            cls.uninstall()
+            raise
 
     @classmethod
     def host_by_role(cls, role):
@@ -55,35 +98,51 @@ class IntegrationTest(object):
     @classmethod
     def get_all_hosts(cls):
         return ([cls.master] + cls.replicas + cls.clients +
-                [cls.host_by_role(r) for r in cls.required_extra_roles])
+                map(cls.host_by_role, cls.required_extra_roles))
 
     @classmethod
     def get_domains(cls):
         return [cls.domain] + cls.ad_domains
 
     @classmethod
-    def install(cls, mh):
-        if cls.domain_level is not None:
-            domain_level = cls.domain_level
-        else:
-            domain_level = cls.master.config.domain_level
+    def prepare_host(cls, host):
+        cls.log.info('Preparing host %s', host.hostname)
+        tasks.prepare_host(host)
+
+    @classmethod
+    def install(cls):
         if cls.topology is None:
             return
         else:
             tasks.install_topo(cls.topology,
-                               cls.master, cls.replicas,
-                               cls.clients, domain_level)
-    @classmethod
-    def teardown_class(cls):
-        pass
+                               cls.master, cls.replicas, cls.clients)
 
     @classmethod
-    def uninstall(cls, mh):
+    def teardown_class(cls):
+        for host in cls.get_all_hosts():
+            host.remove_log_collector(cls.collect_log)
+
+        try:
+            cls.uninstall()
+        finally:
+            del cls.master
+            del cls.replicas
+            del cls.clients
+            del cls.ad_domains
+            del cls.domain
+
+    @classmethod
+    def uninstall(cls):
         tasks.uninstall_master(cls.master)
         for replica in cls.replicas:
             tasks.uninstall_master(replica)
         for client in cls.clients:
             tasks.uninstall_client(client)
 
+    @classmethod
+    def collect_log(cls, host, filename):
+        cls.log.info('Adding %s:%s to list of logs to collect' %
+                     (host.external_hostname, filename))
+        cls.logs_to_collect.setdefault(host, []).append(filename)
 
 IntegrationTest.log = log_mgr.get_logger(IntegrationTest())