final tests

Author: amyasnikov

validity/scripts/runtests/split.py

@@ -63,11 +63,13 @@ def sync_datasources(
     def backup_datasources(self, datasources: QuerySet[VDataSource], logger: Logger) -> None:
         def fail_handler(backup_point, error):
             logger.failure(f"Cannot back up {md_link(backup_point)}. {error}")
+            failed_bp.add(backup_point)
 
-        backup_points = list(self.backup_queryset.filter(data_source__in=datasources))
+        failed_bp = set()
+        backup_points = set(self.backup_queryset.filter(data_source__in=datasources))
         self.backup_fn(backup_points, fail_handler=fail_handler)
-        if backup_points:
-            bp_names = ", ".join(md_link(bp) for bp in backup_points)
+        bp_names = ", ".join(md_link(bp) for bp in backup_points - failed_bp)
+        if bp_names:
             logger.info(f"Data Sources have been backed up using the following Backup Points: {bp_names}")
 
     def _work_slices(

validity/tests/conftest.py

@@ -11,6 +11,7 @@
 
 import validity
 import validity.scripts
+from validity import dependencies
 from validity.models import Poller, Serializer
 from validity.utils.orm import CustomFieldBuilder
 
@@ -97,3 +98,8 @@ def _now(tz):
         monkeypatch.setattr(timezone, "now", lambda: tz)
 
     return _now
+
+
+@pytest.fixture
+def launcher_factory(di):
+    return di[dependencies.launcher_factory]

validity/tests/test_scripts/runtests/test_combine.py

@@ -7,7 +7,6 @@
 
 from validity.scripts.data_models import ExecutionResult, Message
 from validity.scripts.data_models import TestResultRatio as ResultRatio
-from validity.scripts.exceptions import AbortScript
 from validity.scripts.runtests.combine import CombineWorker
 from validity.utils.logger import Logger
 
@@ -56,8 +55,7 @@ def test_call_abort(worker, full_runtests_params, job_extractor, monkeypatch):
     job_extractor.parents[1].job.result.errored = True
     monkeypatch.setattr(timezone, "now", lambda: datetime.datetime(2020, 1, 1))
     worker.job_extractor_factory = lambda: job_extractor
-    with pytest.raises(AbortScript):
-        worker(full_runtests_params)
+    worker(full_runtests_params)
     job = full_runtests_params.get_job()
     assert job.status == "errored"
     assert job.data == {

validity/tests/test_scripts/runtests/test_split.py

@@ -6,8 +6,18 @@
 from django.db.models import Q
 from django.db.models.signals import post_save
 from django.utils import timezone
-from factories import DataSourceFactory, DeviceFactory, RunTestsJobFactory, SelectorFactory, TenantFactory
+from factories import (
+    BackupPointFactory,
+    DataSourceFactory,
+    DeviceFactory,
+    RunTestsJobFactory,
+    SelectorFactory,
+    TenantFactory,
+)
 
+from validity.data_backup import BackupBackend
+from validity.integrations.errors import IntegrationError
+from validity.models import VDataSource
 from validity.scripts.data_models import Message, SplitResult
 from validity.scripts.runtests.split import SplitWorker
 from validity.utils.logger import Logger
@@ -79,6 +89,34 @@ def test_sync_datasources(create_custom_fields, overriding_datasource):
     logger.info.assert_called_once()
 
 
+@pytest.mark.django_db
+def test_backup_datasources_success():
+    backup_fn = Mock()
+    bp1 = BackupPointFactory(backup_after_sync=True, name="bp1")
+    worker = SplitWorker(backup_fn=backup_fn)
+    worker.backup_datasources(VDataSource.objects.all(), Logger())
+    backup_fn.assert_called_once()
+    assert backup_fn.call_args[0][0] == {bp1}
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_backup_datasources_fail(timezone_now, di):
+    timezone_now(datetime.datetime(2000, 1, 2, 3, 4, tzinfo=datetime.timezone.utc))
+    bp = BackupPointFactory(backup_after_sync=True, name="bp1")
+    worker = SplitWorker()
+    backend = Mock(side_effect=IntegrationError("ERR123"))
+    with di.override({BackupBackend: lambda: backend}):
+        worker.backup_datasources(VDataSource.objects.all(), logger := Logger())
+    backend.assert_called_once_with(bp)
+    assert logger.messages == [
+        Message(
+            status="failure",
+            message="Cannot back up [bp1](/plugins/validity/backup-points/1/). ERR123",
+            time=datetime.datetime(2000, 1, 2, 3, 4, tzinfo=datetime.timezone.utc),
+        )
+    ]
+
+
 @pytest.mark.parametrize("device_num", [2])
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_call(selectors, devices, runtests_params, monkeypatch):

validity/tests/test_scripts/test_launcher.py

@@ -5,6 +5,7 @@
 from core.models import Job
 from django.utils import timezone
 from factories import UserFactory
+from rq.queue import Queue
 
 from validity.models import ComplianceReport
 from validity.scripts.data_models import RequestInfo, ScriptParams, Task
@@ -71,3 +72,8 @@ def task_func_2(): ...
     launcher(params)
     assert launcher.rq_queue.enqueue.call_count == 4
     assert launcher.rq_queue.enqueue.call_args.kwargs["depends_on"] == [launcher.rq_queue.enqueue.return_value] * 3
+
+
+def test_factory_getqueue(launcher_factory):
+    queue = launcher_factory.get_queue("default")
+    assert isinstance(queue, Queue)

validity/tests/test_utils/test_logger.py

@@ -1,27 +1,30 @@
+import datetime
+import inspect
+
 import pytest
 
-from validity.utils.logger import Logger
+from validity.utils.logger import Logger, Message
 
 
-@pytest.fixture
+@pytest.fixture(name="err")
 def error_with_traceback():
-    # moving this function up/down will cause the test to fail
     try:
         raise ValueError("error")
     except ValueError as e:
         return e
 
 
-def test_logger(error_with_traceback):
+def test_logger(err):
     logger = Logger()
     logger.info("info-msg")
     logger.failure("failure-msg")
-    logger.log_exception(error_with_traceback)
+    logger.log_exception(err)
 
     assert len(logger.messages) == 3
     serialized_logs = [m.serialized for m in logger.messages]
     for log in serialized_logs:
         del log["time"]
+    line_num = inspect.getsourcelines(error_with_traceback)[1] + 3
     assert serialized_logs == [
         {"status": "info", "message": "info-msg"},
         {"status": "failure", "message": "failure-msg"},
@@ -30,7 +33,32 @@ def test_logger(error_with_traceback):
             "message": (
                 "Unhandled error occured: `<class 'ValueError'>: error`\n```\n  "
                 f'File "{__file__}", '
-                """line 10, in error_with_traceback\n    raise ValueError("error")\n\n```"""
+                f"""line {line_num}, in error_with_traceback\n    raise ValueError("error")\n\n```"""
             ),
         },
     ]
+
+
+def test_as_context():
+    with Logger() as logger:
+        logger.info("msg1")
+        assert logger.messages
+    assert logger.messages == []
+
+
+def test_script_id_context(timezone_now):
+    timezone_now(datetime.datetime(2000, 1, 2, tzinfo=datetime.timezone.utc))
+    logger = Logger()
+    with logger.script_id("script1"):
+        assert logger._script_id == "script1"
+        logger.info("msg1")
+        assert logger.messages == [
+            Message(
+                status="info",
+                message="msg1",
+                time=datetime.datetime(2000, 1, 2, 0, 0, tzinfo=datetime.timezone.utc),
+                script_id="script1",
+            )
+        ]
+    assert logger.messages == []
+    assert logger._script_id is None

validity/utils/logger.py

@@ -50,7 +50,7 @@ def __init__(self) -> None:
         self.messages = []
         self._script_id = None
 
-    def __enter__(self) -> None:
+    def __enter__(self) -> "Logger":
         return self
 
     def __exit__(self, ty, exc, val):
@@ -82,5 +82,5 @@ def log_exception(self, exc_value, exc_type=None, exc_traceback=None):
         self.failure(f"Unhandled error occured: `{exc_type}: {exc_value}`\n```\n{stacktrace}\n```")
 
     def flush(self):
-        self.script_id = None
+        self._script_id = None
         self.messages = []