feat(refactor):

tests/conftest.py

@@ -10,6 +10,7 @@
 from trailblazer.constants import TOWER_TIMESTAMP_FORMAT, TrailblazerStatus, FileFormat
 from trailblazer.io.controller import ReadFile
 from tests.store.utils.store_helper import StoreHelpers
+from trailblazer.store.models import Analysis
 
 
 @pytest.fixture(scope="session", name="username")
@@ -98,20 +99,33 @@ def fixture_user_store(
     yield store
 
 
+@pytest.fixture(name="raw_analyses")
+def fixture_raw_analyses(sample_data: Dict[str, list]) -> List[dict]:
+    """Return raw analyses data."""
+    analyses: List[Analysis] = []
+    for analysis_data in sample_data["analyses"]:
+        analysis_data["case_id"] = analysis_data["family"]
+        analyses.append(analysis_data)
+    return analyses
+
+
 @pytest.fixture(name="sample_store")
 def fixture_sample_store(
-    archived_user_email: str, archived_username: str, sample_data: Dict[str, list], store: MockStore
+    raw_analyses: List[dict],
+    archived_user_email: str,
+    archived_username: str,
+    sample_data: Dict[str, list],
+    store: MockStore,
 ) -> Generator[MockStore, None, None]:
     """A sample Trailblazer database populated with pending analyses."""
     StoreHelpers.add_user(
         email=archived_user_email, name=archived_username, is_archived=True, store=store
     )
     for user_data in sample_data["users"]:
         store.add_user(name=user_data["name"], email=user_data["email"])
-    for analysis_data in sample_data["analyses"]:
-        analysis_data["case_id"] = analysis_data["family"]
-        analysis_data["user"] = store.get_user(email=analysis_data["user"])
-        store.add(store.Analysis(**analysis_data))
+    for raw_analysis in raw_analyses:
+        raw_analysis["user"] = store.get_user(email=raw_analysis["user"])
+        store.add(store.Analysis(**raw_analysis))
     store.commit()
     yield store
 

tests/store/crud/test_update.py

@@ -1,12 +1,39 @@
+from typing import List
+
 from tests.mocks.store_mock import MockStore
 from trailblazer.store.filters.user_filters import apply_user_filter, UserFilter
-from trailblazer.store.models import User
+from trailblazer.store.models import User, Analysis
+
+
+def test_add_pending_analysis(raw_analyses: List[dict], store: MockStore):
+    """Test adding a new analysis to the database."""
+    # GIVEN an empty database
+    assert not store.get_query(table=Analysis).first()
+
+    analysis: dict = raw_analyses[0]
+
+    # WHEN adding a new analysis
+    new_analysis: Analysis = store.add_pending_analysis(
+        case_id=analysis.get("family"),
+        config_path=analysis.get("config_path"),
+        out_dir=analysis.get("out_dir"),
+        priority=analysis.get("priority"),
+        type=analysis.get("type"),
+    )
+
+    # THEN it should be stored in the database
+    stored_analysis: Analysis = store.get_analysis(
+        case_id=analysis.get("family"),
+        started_at=new_analysis.started_at,
+        status=analysis.get("status"),
+    )
+    assert stored_analysis == new_analysis
 
 
 def test_add_user(store: MockStore, user_email: str, username: str):
     """Test adding a user."""
     # GIVEN an empty database
-    assert store.get_query(table=User).first() is None
+    assert not store.get_query(table=User).first()
 
     # WHEN adding a new user
     new_user: User = store.add_user(name=username, email=user_email)

trailblazer/server/api.py

@@ -8,7 +8,7 @@
 from google.auth import jwt
 
 from trailblazer.server.ext import store
-from trailblazer.store.models import Info, User
+from trailblazer.store.models import Info, User, Analysis
 
 blueprint = Blueprint("api", __name__, url_prefix="/api/v1")
 
@@ -231,24 +231,23 @@ def post_mark_analyses_deleted():
 
 @blueprint.route("/add-pending-analysis", methods=["POST"])
 def post_add_pending_analysis():
-    """Add new analysis with pending status"""
-    content = request.json
+    """Add new analysis with status: pending."""
     try:
-        analysis_obj = store.add_pending_analysis(
-            case_id=content.get("case_id"),
-            email=content.get("email"),
-            type=content.get("type"),
-            config_path=content.get("config_path"),
-            out_dir=content.get("out_dir"),
-            priority=content.get("priority"),
-            data_analysis=content.get("data_analysis"),
-            ticket_id=content.get("ticket"),
-            workflow_manager=content.get("workflow_manager"),
+        analysis: Analysis = store.add_pending_analysis(
+            case_id=request.json.get("case_id"),
+            email=request.json.get("email"),
+            type=request.json.get("type"),
+            config_path=request.json.get("config_path"),
+            out_dir=request.json.get("out_dir"),
+            priority=request.json.get("priority"),
+            data_analysis=request.json.get("data_analysis"),
+            ticket_id=request.json.get("ticket"),
+            workflow_manager=request.json.get("workflow_manager"),
         )
-        data = stringify_timestamps(analysis_obj.to_dict())
-        return jsonify(**data), 201
-    except Exception as e:
-        return jsonify(f"Exception: {e}"), 409
+        raw_analysis: dict = stringify_timestamps(analysis.to_dict())
+        return jsonify(**raw_analysis), 201
+    except Exception as exception:
+        return jsonify(f"Exception: {exception}"), 409
 
 
 @blueprint.route("/set-analysis-uploaded", methods=["PUT"])

trailblazer/store/api.py

@@ -149,36 +149,6 @@ def has_latest_analysis_started(self, case_id: str) -> bool:
         latest_analysis_status = self.get_latest_analysis_status(case_id=case_id)
         return latest_analysis_status in STARTED_STATUSES
 
-    def add_pending_analysis(
-        self,
-        case_id: str,
-        type: str,
-        config_path: str,
-        out_dir: str,
-        priority: str,
-        email: str = None,
-        data_analysis: str = None,
-        ticket_id: str = None,
-        workflow_manager: str = None,
-    ) -> Analysis:
-        """Add pending entry for an analysis."""
-        started_at = dt.datetime.now()
-        new_log = self.Analysis(
-            family=case_id,
-            status="pending",
-            started_at=started_at,
-            type=type,
-            config_path=config_path,
-            out_dir=out_dir,
-            priority=priority,
-            data_analysis=data_analysis,
-            ticket_id=ticket_id,
-            workflow_manager=workflow_manager,
-        )
-        new_log.user = self.get_user(email=email) if email else None
-        self.add_commit(new_log)
-        return new_log
-
     def jobs(self) -> Query:
         """Return all jobs in the database."""
         return self.Job.query

trailblazer/store/crud/update.py

@@ -1,10 +1,42 @@
+from datetime import datetime
+
+from trailblazer.constants import TrailblazerStatus
 from trailblazer.store.base import BaseHandler_2
-from trailblazer.store.models import User
+from trailblazer.store.models import User, Analysis
 
 
 class UpdateHandler(BaseHandler_2):
     """Class for updating items in the database."""
 
+    def add_pending_analysis(
+        self,
+        case_id: str,
+        config_path: str,
+        out_dir: str,
+        priority: str,
+        type: str,
+        email: str = None,
+        data_analysis: str = None,
+        ticket_id: str = None,
+        workflow_manager: str = None,
+    ) -> Analysis:
+        """Add pending analysis with user if supplied with email."""
+        new_analysis: Analysis = Analysis(
+            config_path=config_path,
+            data_analysis=data_analysis,
+            family=case_id,
+            out_dir=out_dir,
+            priority=priority,
+            started_at=datetime.now(),
+            status=TrailblazerStatus.PENDING.value,
+            ticket_id=ticket_id,
+            type=type,
+            workflow_manager=workflow_manager,
+        )
+        new_analysis.user = self.get_user(email=email) if email else None
+        self.add_commit(new_analysis)
+        return new_analysis
+
     def add_user(self, name: str, email: str) -> User:
         """Add a new user to the database."""
         new_user: User = User(email=email, name=name)