Remove most of qiskit.test

This removes large tracts of `qiskit.test` that Qiskit itself is no
longer using, or inlines a couple of components that were either
exceptionally simple or used only once.  A few tests that made heavier
use of the removed features have been removed rather than replacing the
functionality, since those had not actually been running due to
dependencies on IBMQ that have not been fulfilled for a long time.

This prepares for a more complete removal of `qiskit.test`, if we choose
to, but such a change raises the possibility of rather more merge
conflicts (due to the need to touch every test file), so is best done
separately.

Author: jakelishman

qiskit/test/__init__.py

@@ -13,6 +13,4 @@
 """Functionality and helpers for testing Qiskit."""
 
 from .base import QiskitTestCase
-from .decorators import requires_aer_provider, online_test, slow_test
-from .reference_circuits import ReferenceCircuits
-from .utils import Path
+from .decorators import slow_test

qiskit/test/base.py

@@ -32,7 +32,6 @@
 from qiskit.utils import optionals as _optionals
 from qiskit.circuit import QuantumCircuit
 from .decorators import enforce_subclasses_call
-from .utils import Path, setup_test_logging
 
 
 __unittest = True  # Allows shorter stack trace for .assertDictAlmostEqual
@@ -99,19 +98,6 @@ def tearDown(self):
             )
         self.__teardown_called = True
 
-    @staticmethod
-    def _get_resource_path(filename, path=Path.TEST):
-        """Get the absolute path to a resource.
-
-        Args:
-            filename (string): filename or relative path to the resource.
-            path (Path): path used as relative to the filename.
-
-        Returns:
-            str: the absolute path to the resource.
-        """
-        return os.path.normpath(os.path.join(path.value, filename))
-
     def assertQuantumCircuitEqual(self, qc1, qc2, msg=None):
         """Extra assertion method to give a better error message when two circuits are unequal."""
         if qc1 == qc2:
@@ -192,13 +178,26 @@ def tearDown(self):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        # Determines if the TestCase is using IBMQ credentials.
-        cls.using_ibmq_credentials = False
         # Set logging to file and stdout if the LOG_LEVEL envar is set.
         cls.log = logging.getLogger(cls.__name__)
-        if os.getenv("LOG_LEVEL"):
-            filename = "%s.log" % os.path.splitext(inspect.getfile(cls))[0]
-            setup_test_logging(cls.log, os.getenv("LOG_LEVEL"), filename)
+
+        if log_level := os.getenv("LOG_LEVEL"):
+            log_fmt = f"{cls.log.name}.%(funcName)s:%(levelname)s:%(asctime)s: %(message)s"
+            formatter = logging.Formatter(log_fmt)
+            file_handler = logging.FileHandler(f"{os.path.splitext(inspect.getfile(cls))[0]}.log")
+            file_handler.setFormatter(formatter)
+            cls.log.addHandler(file_handler)
+
+            if os.getenv("STREAM_LOG"):
+                # Set up the stream handler.
+                stream_handler = logging.StreamHandler()
+                stream_handler.setFormatter(formatter)
+                cls.log.addHandler(stream_handler)
+
+            # Set the logging level from the environment variable, defaulting
+            # to INFO if it is not a valid level.
+            level = logging._nameToLevel.get(log_level, logging.INFO)
+            cls.log.setLevel(level)
 
         warnings.filterwarnings("error", category=DeprecationWarning)
         allow_DeprecationWarning_modules = [

qiskit/test/decorators.py

@@ -13,69 +13,12 @@
 
 """Decorator for using with Qiskit unit tests."""
 
-import collections.abc
 import functools
 import os
-import socket
-import sys
-from typing import Union, Callable, Type, Iterable
 import unittest
+from typing import Union, Callable, Type, Iterable
 
 from qiskit.utils import wrap_method
-from .testing_options import get_test_options
-
-HAS_NET_CONNECTION = None
-
-
-def _has_connection(hostname, port):
-    """Checks if internet connection exists to host via specified port.
-
-    If any exception is raised while trying to open a socket this will return
-    false.
-
-    Args:
-        hostname (str): Hostname to connect to.
-        port (int): Port to connect to
-
-    Returns:
-        bool: Has connection or not
-
-    """
-    try:
-        host = socket.gethostbyname(hostname)
-        socket.create_connection((host, port), 2).close()
-        return True
-    except Exception:  # pylint: disable=broad-except
-        return False
-
-
-def is_aer_provider_available():
-    """Check if the C++ simulator can be instantiated.
-
-    Returns:
-        bool: True if simulator executable is available
-    """
-    # TODO: HACK FROM THE DEPTHS OF DESPAIR AS AER DOES NOT WORK ON MAC
-    if sys.platform == "darwin":
-        return False
-    try:
-        import qiskit.providers.aer  # pylint: disable=unused-import
-    except ImportError:
-        return False
-    return True
-
-
-def requires_aer_provider(test_item):
-    """Decorator that skips test if qiskit aer provider is not available
-
-    Args:
-        test_item (callable): function or class to be decorated.
-
-    Returns:
-        callable: the decorated function.
-    """
-    reason = "Aer provider not found, skipping test"
-    return unittest.skipIf(not is_aer_provider_available(), reason)(test_item)
 
 
 def slow_test(func):
@@ -90,100 +33,13 @@ def slow_test(func):
 
     @functools.wraps(func)
     def _wrapper(*args, **kwargs):
-        skip_slow = not TEST_OPTIONS["run_slow"]
-        if skip_slow:
+        if "run_slow" in os.environ.get("QISKIT_TESTS", ""):
             raise unittest.SkipTest("Skipping slow tests")
-
         return func(*args, **kwargs)
 
     return _wrapper
 
 
-def _get_credentials():
-    """Finds the credentials for a specific test and options.
-
-    Returns:
-        Credentials: set of credentials
-
-    Raises:
-        SkipTest: when credentials can't be found
-    """
-    try:
-        from qiskit.providers.ibmq.credentials import Credentials, discover_credentials
-    except ImportError as ex:
-        raise unittest.SkipTest(
-            "qiskit-ibmq-provider could not be found, "
-            "and is required for executing online tests. "
-            'To install, run "pip install qiskit-ibmq-provider" '
-            "or check your installation."
-        ) from ex
-
-    if os.getenv("IBMQ_TOKEN") and os.getenv("IBMQ_URL"):
-        return Credentials(os.getenv("IBMQ_TOKEN"), os.getenv("IBMQ_URL"))
-    elif os.getenv("QISKIT_TESTS_USE_CREDENTIALS_FILE"):
-        # Attempt to read the standard credentials.
-        discovered_credentials = discover_credentials()
-
-        if discovered_credentials:
-            # Decide which credentials to use for testing.
-            if len(discovered_credentials) > 1:
-                raise unittest.SkipTest(
-                    "More than 1 credential set found, use: "
-                    "IBMQ_TOKEN and IBMQ_URL env variables to "
-                    "set credentials explicitly"
-                )
-
-            # Use the first available credentials.
-            return list(discovered_credentials.values())[0]
-    raise unittest.SkipTest(
-        "No IBMQ credentials found for running the test. This is required for running online tests."
-    )
-
-
-def online_test(func):
-    """Decorator that signals that the test uses the network (and the online API):
-
-    It involves:
-        * determines if the test should be skipped by checking environment
-            variables.
-        * if the `USE_ALTERNATE_ENV_CREDENTIALS` environment variable is
-          set, it reads the credentials from an alternative set of environment
-          variables.
-        * if the test is not skipped, it reads `qe_token` and `qe_url` from
-            `Qconfig.py`, environment variables or qiskitrc.
-        * if the test is not skipped, it appends `qe_token` and `qe_url` as
-            arguments to the test function.
-
-    Args:
-        func (callable): test function to be decorated.
-
-    Returns:
-        callable: the decorated function.
-    """
-
-    @functools.wraps(func)
-    def _wrapper(self, *args, **kwargs):
-        # To avoid checking the connection in each test
-        global HAS_NET_CONNECTION  # pylint: disable=global-statement
-
-        if TEST_OPTIONS["skip_online"]:
-            raise unittest.SkipTest("Skipping online tests")
-
-        if HAS_NET_CONNECTION is None:
-            HAS_NET_CONNECTION = _has_connection("qiskit.org", 443)
-
-        if not HAS_NET_CONNECTION:
-            raise unittest.SkipTest("Test requires internet connection.")
-
-        credentials = _get_credentials()
-        self.using_ibmq_credentials = credentials.is_ibmq()
-        kwargs.update({"qe_token": credentials.token, "qe_url": credentials.url})
-
-        return func(self, *args, **kwargs)
-
-    return _wrapper
-
-
 def enforce_subclasses_call(
     methods: Union[str, Iterable[str]], attr: str = "_enforce_subclasses_call_cache"
 ) -> Callable[[Type], Type]:
@@ -278,31 +134,3 @@ def decorator(cls):
         return cls
 
     return decorator
-
-
-class _TestOptions(collections.abc.Mapping):
-    """Lazy-loading view onto the test options retrieved from the environment."""
-
-    __slots__ = ("_options",)
-
-    def __init__(self):
-        self._options = None
-
-    def _load(self):
-        if self._options is None:
-            self._options = get_test_options()
-
-    def __getitem__(self, key):
-        self._load()
-        return self._options[key]
-
-    def __iter__(self):
-        self._load()
-        return iter(self._options)
-
-    def __len__(self):
-        self._load()
-        return len(self._options)
-
-
-TEST_OPTIONS = _TestOptions()