Overhaul test suite with fixtures

python/nav/Snmp/__init__.py

@@ -21,6 +21,8 @@
 
 """
 from __future__ import absolute_import
+import os
+import sys
 
 BACKEND = None
 
@@ -35,6 +37,12 @@
 # These wildcard imports are informed, not just accidents.
 # pylint: disable=W0401
 if BACKEND == 'pynetsnmp':
+    if sys.platform == "darwin" and not os.getenv("DYLD_LIBRARY_PATH"):
+        # horrible workaround for MacOS problems, described at length at
+        # https://hynek.me/articles/macos-dyld-env/
+        os.environ["DYLD_LIBRARY_PATH"] = os.getenv(
+            "LD_LIBRARY_PATH", "/usr/local/opt/openssl/lib"
+        )
     from .pynetsnmp import *
 else:
     raise ImportError("No supported SNMP backend was found")

python/nav/tests/cases.py

@@ -14,8 +14,14 @@
 # License along with NAV. If not, see <http://www.gnu.org/licenses/>.
 #
 """NAV test cases"""
+import pytest
 import django.test
 
 
 class DjangoTransactionTestCase(django.test.TestCase):
     serialized_rollback = True
+
+    @pytest.fixture(autouse=True)
+    def requirements(self, postgresql):
+        """Ensures the required pytest fixtures are loaded implicitly for all these tests"""
+        pass

python/nav/web/info/room/views.py

@@ -236,7 +236,7 @@ def render_netboxes(request, roomid):
 
 
 @require_http_methods(['POST'])
-def create_csv(request):
+def create_csv(request) -> HttpResponse:
     """Create csv-file from form data"""
     roomname = request.POST.get('roomid', 'room').encode('utf-8')
     filename = "{}.csv".format(roomname)

tests/conftest.py

@@ -0,0 +1,129 @@
+"""Pytest config and fixtures for all test suites"""
+import os
+import subprocess
+
+import pytest
+from retry import retry
+import requests
+
+
+def is_running_in_github_actions():
+    """Returns True if running under GitHub Actions"""
+    return os.getenv("GITHUB_ACTIONS")
+
+
+def _get_preferred_database_name():
+    if is_running_in_github_actions():
+        if not os.getenv("PGDATABASE") and os.getenv("TOX_ENV_NAME"):
+            # Generate an appropriately unique database name for this test run
+            return "{prefix}_{suffix}".format(
+                prefix=os.getenv("GITHUB_RUN_ID", "tox"),
+                suffix=os.getenv("TOX_ENV_NAME").replace("-", "_"),
+            )
+    return "nav"
+
+
+@pytest.fixture(scope='session')
+def postgresql(request):
+    """Fixture for all tests that depend on a running PostgreSQL server. This fixture
+    will try to detect and use an existing PostgreSQL instance (like if running in a
+    GitHub action), otherwise it will set up a temporary PostgreSQL server for the test
+    session.
+
+    If your test needs to write to the database, it should ask for the `db` fixture
+    instead, as this ensures changes are rolled back when the test is done.  However,
+    if your test makes db changes that need to be visible from another process, you
+    must make your own data fixture to ensure the data is removed when the test is
+    done.
+    """
+    if not is_running_in_github_actions():
+        request.getfixturevalue("docker_services")
+
+    dbname = _get_preferred_database_name()
+    _update_db_conf_for_test_run(dbname)
+    _populate_test_database(dbname)
+    yield dbname
+    print("postgres fixture is done")
+
+
+def _update_db_conf_for_test_run(database_name):
+    db_conf_path = os.path.join(os.getenv("BUILDDIR"), "etc/db.conf")
+
+    pghost = os.getenv('PGHOST', 'localhost')
+    pgport = os.getenv('PGPORT', '5432')
+    pguser = os.getenv('PGUSER', 'nav')
+    pgpassword = os.getenv('PGPASSWORD', 'nav')
+    with open(db_conf_path, "w") as output:
+        output.writelines(
+            [
+                f"dbhost={pghost}\n",
+                f"dbport={pgport}\n",
+                f"db_nav={database_name}\n",
+                f"script_default={pguser}\n",
+                f"userpw_{pguser}={pgpassword}\n",
+                "\n",
+            ]
+        )
+    return db_conf_path
+
+
+@retry(Exception, tries=3, delay=2, backoff=2)
+def _populate_test_database(database_name):
+    # Init/sync db schema
+    env = {
+        'PGHOST': 'localhost',
+        'PGUSER': 'nav',
+        'PGDATABASE': database_name,
+        'PGPORT': '5432',
+        'PGPASSWORD': 'nav',
+        'PATH': os.getenv("PATH"),
+    }
+    navsyncdb_path = os.path.join(os.getenv("BUILDDIR"), 'bin', 'navsyncdb')
+    subprocess.check_call([navsyncdb_path], env=env)  # , '-c'], #, '--drop-database'],
+
+    # reset password of NAV admin account if indicated by environment
+    adminpassword = os.getenv("ADMINPASSWORD")
+    if adminpassword:
+        sql = f"UPDATE account SET password = {adminpassword!r} WHERE login='admin'"
+        subprocess.check_call(["psql", "-c", sql, database_name])
+
+    # Add generic test data set
+    test_data_path = './tests/docker/scripts/test-data.sql'
+    subprocess.check_call(["psql", "-f", test_data_path, database_name], env=env)
+
+
+@pytest.fixture(scope='session')
+def gunicorn(postgresql):
+    workspace = os.path.join(os.environ.get('WORKSPACE', ''), 'reports')
+    errorlog = os.path.join(workspace, 'gunicorn-error.log')
+    accesslog = os.path.join(workspace, 'gunicorn-access.log')
+    gunicorn = subprocess.Popen(
+        [
+            'gunicorn',
+            '--error-logfile',
+            errorlog,
+            '--access-logfile',
+            accesslog,
+            'navtest_wsgi:application',
+        ]
+    )
+    # Fire off an initial request to ensure the webserver is actually running
+    response = requests.get("http://localhost:8000/")
+    assert response.status_code == 200, response.content
+    yield gunicorn
+    gunicorn.terminate()
+
+
+@pytest.fixture(scope='session')
+def web_target_url():
+    yield "http://localhost:8000/"
+
+
+@pytest.fixture(scope='session')
+def web_admin_username():
+    yield "admin"
+
+
+@pytest.fixture(scope='session')
+def web_admin_password():
+    yield "admin"

tests/docker-compose.yml

@@ -0,0 +1,18 @@
+# This defines external services that the integration tests depend on. Under
+# various CI systems, such as GitHub Actions, these services may be provided
+# externally. If the test suite deems that they aren't available externally,
+# they may be run locally using these definitions instead.
+---
+version: '3.5'
+
+services:
+  postgres:
+    image: docker.io/postgres:11
+    environment:
+      - POSTGRES_USER=nav
+      - POSTGRES_PASSWORD=nav
+      - POSTGRES_DB=nav
+    ports:
+      - 5432:5432
+    tmpfs:
+      /var/lib/postgresql/data

tests/functional/conftest.py

@@ -1,52 +1,11 @@
 import os
-import subprocess
 
 import pytest
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 
 USERNAME = 'admin'
-gunicorn = None
-
-########################################################################
-#                                                                      #
-# Set up the required components for an integration test. Components   #
-# such as PostgreSQL and Apache are assumed to already be installed on #
-# the system. The system is assumed to be Debian. See                  #
-# tests/docker/Dockerfile.                                             #
-#                                                                      #
-########################################################################
-
-if os.environ.get('WORKSPACE'):
-    SCRIPT_PATH = os.path.join(os.environ['WORKSPACE'], 'tests/docker/scripts')
-else:
-    SCRIPT_PATH = '/'
-SCRIPT_CREATE_DB = os.path.join(SCRIPT_PATH, 'create-db.sh')
-
-
-def pytest_configure(config):
-    subprocess.check_call([SCRIPT_CREATE_DB])
-    start_gunicorn()
-
-
-def pytest_unconfigure(config):
-    stop_gunicorn()
-
-
-def start_gunicorn():
-    global gunicorn
-    gunicorn_log = open("reports/gunicorn.log", "ab")
-    gunicorn = subprocess.Popen(
-        ['gunicorn', 'navtest_wsgi:application'],
-        stdout=gunicorn_log,
-        stderr=subprocess.STDOUT,
-    )
-
-
-def stop_gunicorn():
-    if gunicorn:
-        gunicorn.terminate()
 
 
 ############

tests/integration/alertengine_test.py

@@ -2,7 +2,7 @@
 from nav.alertengine.dispatchers import Dispatcher
 
 
-def test_all_handlers_should_be_loadable():
+def test_all_handlers_should_be_loadable(postgresql):
     for sender in AlertSender.objects.filter(supported=True):
         dispatcher = sender.load_dispatcher_class()
         assert issubclass(dispatcher, Dispatcher)

tests/integration/auditlog_test.py

@@ -1,4 +1,4 @@
-from django.test import TestCase
+from nav.tests.cases import DjangoTransactionTestCase
 
 from nav.models.arnold import Justification
 
@@ -7,7 +7,7 @@
 from nav.auditlog.utils import get_auditlog_entries
 
 
-class AuditlogModelTestCase(TestCase):
+class AuditlogModelTestCase(DjangoTransactionTestCase):
     def setUp(self):
         # This specific model is used because it is very simple
         self.justification = Justification.objects.create(name='testarossa')
@@ -80,7 +80,7 @@ def test_find_name(self):
         self.assertEqual(name, 'blocked_reason')
 
 
-class AuditlogUtilsTestCase(TestCase):
+class AuditlogUtilsTestCase(DjangoTransactionTestCase):
     def setUp(self):
         # This specific model is used because it is very simple
         self.justification = Justification.objects.create(name='testarossa')

tests/integration/bin_test.py

@@ -1,10 +1,14 @@
-import pytest
-import sys
+from shutil import which
 import subprocess
 
+import pytest
+
 
-def test_binary_runs(binary):
+def test_binary_runs(postgresql, binary):
     """Verifies that a command runs with a zero exit code"""
+    if "netbiostracker" in binary[0] and not which("nbtscan"):
+        pytest.skip("nbtscan is not installed")
+
     proc = subprocess.Popen(binary, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
     (done, fail) = proc.communicate()
     retcode = proc.wait()