Add 'run_slow' handling and requires_extra_library unit test decorator (

#104) (#105)

.github/actions/run-tests/action.yml

@@ -16,15 +16,18 @@ inputs:
   event-name:
     description: 'Actions event'
     required: true
+  run-slow:
+    description: 'Run slow tests or not'
+    required: true
   python-version:
     description: 'Python version'
     required: true
 runs:
   using: "composite"
   steps: 
     - run: |
-        # run slow tests only on scheduled event
-        if [ "${{ inputs.event-name }}" == "schedule" ]; then
+        # run slow tests only on scheduled event or if input flag is set
+        if [ "${{ inputs.event-name }}" == "schedule" ] || [ "${{ inputs.run-slow }}" == "true" ]; then
           export QISKIT_TESTS="run_slow"
         fi
         if [ "${{ inputs.python-version }}" == "3.7" ]; then

.github/workflows/main.yml

@@ -112,6 +112,7 @@ jobs:
   Optimization:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: [3.6, 3.7, 3.8, 3.9]
     steps:
@@ -129,6 +130,7 @@ jobs:
         uses: ./.github/actions/run-tests
         with:
           event-name: ${{ github.event_name }}
+          run-slow: ${{ contains(github.event.pull_request.labels.*.name, 'run_slow') }}
           python-version: ${{ matrix.python-version }}
       - name: Deprecation Messages
         run: |
@@ -148,7 +150,7 @@ jobs:
       - name: Optimization Unit Tests without cplex/cvxpy/matplotlib under Python ${{ matrix.python-version }}
         run: |
           pip uninstall -y cplex cvxpy matplotlib
-          if [ "${{ github.event_name }}" == "schedule" ]; then
+          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ contains(github.event.pull_request.labels.*.name, 'run_slow') }}" == "true" ]; then
               export QISKIT_TESTS="run_slow"
           fi
           stestr --test-path test run

test/__init__.py

@@ -12,6 +12,10 @@
 
 """ Optimization test packages """
 
-from .optimization_test_case import QiskitOptimizationTestCase
+from .optimization_test_case import (QiskitOptimizationTestCase,
+                                     requires_extra_library)
 
-__all__ = ['QiskitOptimizationTestCase']
+__all__ = [
+    'QiskitOptimizationTestCase',
+    'requires_extra_library'
+]

test/algorithms/test_cplex_optimizer.py

@@ -13,9 +13,8 @@
 """ Test Cplex Optimizer """
 
 import unittest
-from test.optimization_test_case import QiskitOptimizationTestCase
+from test.optimization_test_case import QiskitOptimizationTestCase, requires_extra_library
 from ddt import ddt, data
-from qiskit.exceptions import MissingOptionalLibraryError
 from qiskit_optimization.algorithms import CplexOptimizer
 from qiskit_optimization.problems import QuadraticProgram
 
@@ -24,20 +23,15 @@
 class TestCplexOptimizer(QiskitOptimizationTestCase):
     """Cplex Optimizer Tests."""
 
-    def setUp(self):
-        super().setUp()
-        try:
-            self.cplex_optimizer = CplexOptimizer(disp=False)
-        except MissingOptionalLibraryError as ex:
-            self.skipTest(str(ex))
-
     @data(
         ('op_ip1.lp', [0, 2], 6),
         ('op_mip1.lp', [1, 1, 0], 6),
         ('op_lp1.lp', [0.25, 1.75], 5.8750)
     )
+    @requires_extra_library
     def test_cplex_optimizer(self, config):
         """ Cplex Optimizer Test """
+        cplex_optimizer = CplexOptimizer(disp=False)
         # unpack configuration
         filename, x, fval = config
 
@@ -47,7 +41,7 @@ def test_cplex_optimizer(self, config):
         problem.read_from_lp_file(lp_file)
 
         # solve problem with cplex
-        result = self.cplex_optimizer.solve(problem)
+        result = cplex_optimizer.solve(problem)
 
         # analyze results
         self.assertAlmostEqual(result.fval, fval)

test/algorithms/test_goemans_williamson_optimizer.py

@@ -11,10 +11,9 @@
 # that they have been altered from the originals.
 
 """ Test Goemans-Williamson optimizer. """
-from test import QiskitOptimizationTestCase
+from test import QiskitOptimizationTestCase, requires_extra_library
 
 import numpy as np
-from qiskit.exceptions import MissingOptionalLibraryError
 
 from qiskit_optimization.algorithms.goemans_williamson_optimizer \
     import (GoemansWilliamsonOptimizer, GoemansWilliamsonOptimizationResult)
@@ -23,30 +22,29 @@
 
 class TestGoemansWilliamson(QiskitOptimizationTestCase):
     """Test Goemans-Williamson optimizer."""
+
+    @requires_extra_library
     def test_all_cuts(self):
         """Basic test of the Goemans-Williamson optimizer."""
-        try:
-            graph = np.array([[0., 1., 2., 0.],
-                              [1., 0., 1., 0.],
-                              [2., 1., 0., 1.],
-                              [0., 0., 1., 0.]])
+        graph = np.array([[0., 1., 2., 0.],
+                          [1., 0., 1., 0.],
+                          [2., 1., 0., 1.],
+                          [0., 0., 1., 0.]])
 
-            optimizer = GoemansWilliamsonOptimizer(num_cuts=10, seed=0)
+        optimizer = GoemansWilliamsonOptimizer(num_cuts=10, seed=0)
 
-            problem = Maxcut(graph).to_quadratic_program()
-            self.assertIsNotNone(problem)
+        problem = Maxcut(graph).to_quadratic_program()
+        self.assertIsNotNone(problem)
 
-            results = optimizer.solve(problem)
-            self.assertIsNotNone(results)
-            self.assertIsInstance(results, GoemansWilliamsonOptimizationResult)
+        results = optimizer.solve(problem)
+        self.assertIsNotNone(results)
+        self.assertIsInstance(results, GoemansWilliamsonOptimizationResult)
 
-            self.assertIsNotNone(results.x)
-            np.testing.assert_almost_equal([0, 1, 1, 0], results.x, 3)
+        self.assertIsNotNone(results.x)
+        np.testing.assert_almost_equal([0, 1, 1, 0], results.x, 3)
 
-            self.assertIsNotNone(results.fval)
-            np.testing.assert_almost_equal(4, results.fval, 3)
+        self.assertIsNotNone(results.fval)
+        np.testing.assert_almost_equal(4, results.fval, 3)
 
-            self.assertIsNotNone(results.samples)
-            self.assertEqual(3, len(results.samples))
-        except MissingOptionalLibraryError as ex:
-            self.skipTest(str(ex))
+        self.assertIsNotNone(results.samples)
+        self.assertEqual(3, len(results.samples))

test/algorithms/test_min_eigen_optimizer.py

@@ -13,13 +13,12 @@
 """ Test Min Eigen Optimizer """
 
 import unittest
-from test.optimization_test_case import QiskitOptimizationTestCase
+from test.optimization_test_case import QiskitOptimizationTestCase, requires_extra_library
 
 import numpy as np
 from ddt import data, ddt
 
 from qiskit import BasicAer
-from qiskit.exceptions import MissingOptionalLibraryError
 from qiskit.utils import QuantumInstance, algorithm_globals
 from qiskit.algorithms import QAOA, NumPyMinimumEigensolver
 from qiskit.algorithms.optimizers import COBYLA
@@ -52,6 +51,7 @@ def setUp(self):
         ('qaoa', 'statevector_simulator', 'op_ip1.lp'),
         ('qaoa', 'qasm_simulator', 'op_ip1.lp')
     )
+    @requires_extra_library
     def test_min_eigen_optimizer(self, config):
         """ Min Eigen Optimizer Test """
         try:
@@ -84,15 +84,14 @@ def test_min_eigen_optimizer(self, config):
 
             # check that eigensolver result is present
             self.assertIsNotNone(result.min_eigen_solver_result)
-        except MissingOptionalLibraryError as ex:
-            self.skipTest(str(ex))
         except RuntimeError as ex:
             self.fail(str(ex))
 
     @data(
         ('op_ip1.lp', -470, 12, OptimizationResultStatus.SUCCESS),
         ('op_ip1.lp', np.inf, None, OptimizationResultStatus.FAILURE),
     )
+    @requires_extra_library
     def test_min_eigen_optimizer_with_filter(self, config):
         """ Min Eigen Optimizer Test """
         try:
@@ -127,8 +126,6 @@ def filter_criterion(x, v, aux):
 
             # check that eigensolver result is present
             self.assertIsNotNone(result.min_eigen_solver_result)
-        except MissingOptionalLibraryError as ex:
-            self.skipTest(str(ex))
         except RuntimeError as ex:
             self.fail(str(ex))