Refactor of API versus JBI, and leverage of pytest fixtures for smaller tests (#76)

* Group all API endpoints into ``src.app``

* Do not import module on each request

* Use Actions model instead of Mapping

* Move configuration to src.app

* Test webhook in api tests

* Rewrite router tests without HTTP

* Rename src.jbi.router to src.jbi.runner

* Show action module in logs

* Refactor tests to leverage pytest features

* Rename bad config file

* Use explicit folders for templates and static

* Add trailing slash in powered_by_jbi URL (for consistency with others)

* Allow None in Actions.get()

* Add tests for views

* Leverage fixtures in monitor tests

* Test all endpoints

* Test default action commenting

* Add tests for configuration

* Add missing tests for bugzilla comments

* Migrate default_with_status_and_assignee to fixtures

* @grahamalama review

Author: leplatrem

src/app/api.py

@@ -4,17 +4,29 @@
 import logging
 import time
 from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
 
 import sentry_sdk
 import uvicorn  # type: ignore
-from fastapi import FastAPI, Request
+from fastapi import Body, Depends, FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 
+from src.app import configuration
 from src.app.environment import get_settings
 from src.app.log import configure_logging
 from src.app.monitor import api_router as monitor_router
-from src.jbi.router import api_router as jbi_router
+from src.jbi.bugzilla import BugzillaWebhookRequest
+from src.jbi.models import Actions
+from src.jbi.runner import IgnoreInvalidRequestError, execute_action
+from src.jbi.services import get_jira
+
+SRC_DIR = Path(__file__).parents[1]
+
+templates = Jinja2Templates(directory=SRC_DIR / "templates")
 
 settings = get_settings()
 
@@ -27,8 +39,7 @@
 )
 
 app.include_router(monitor_router)
-app.include_router(jbi_router)
-app.mount("/static", StaticFiles(directory="src/static"), name="static")
+app.mount("/static", StaticFiles(directory=SRC_DIR / "static"), name="static")
 
 sentry_sdk.init(  # pylint: disable=abstract-class-instantiated  # noqa: E0110
     dsn=settings.sentry_dsn
@@ -78,6 +89,56 @@ async def request_summary(request: Request, call_next):
     return response
 
 
+@app.post("/bugzilla_webhook")
+def bugzilla_webhook(
+    request: BugzillaWebhookRequest = Body(..., embed=False),
+    actions: Actions = Depends(configuration.get_actions),
+):
+    """API endpoint that Bugzilla Webhook Events request"""
+    try:
+        result = execute_action(request, actions, settings)
+        return JSONResponse(content=result, status_code=200)
+    except IgnoreInvalidRequestError as exception:
+        return JSONResponse(content={"error": str(exception)}, status_code=200)
+
+
+@app.get("/whiteboard_tags/")
+def get_whiteboard_tag(
+    whiteboard_tag: Optional[str] = None,
+    actions: Actions = Depends(configuration.get_actions),
+):
+    """API for viewing whiteboard_tags and associated data"""
+    if existing := actions.get(whiteboard_tag):
+        return {whiteboard_tag: existing}
+    return actions.all()
+
+
+@app.get("/jira_projects/")
+def get_jira_projects():
+    """API for viewing projects that are currently accessible by API"""
+    jira = get_jira()
+    visible_projects: List[Dict] = jira.projects(included_archived=None)
+    return [project["key"] for project in visible_projects]
+
+
+@app.get("/powered_by_jbi/", response_class=HTMLResponse)
+def powered_by_jbi(
+    request: Request,
+    enabled: Optional[bool] = None,
+    actions: Actions = Depends(configuration.get_actions),
+):
+    """API for `Powered By` endpoint"""
+    entries = actions.all()
+    context = {
+        "request": request,
+        "title": "Powered by JBI",
+        "num_configs": len(entries),
+        "data": entries,
+        "enable_query": enabled,
+    }
+    return templates.TemplateResponse("powered_by_template.html", context)
+
+
 if __name__ == "__main__":
     uvicorn.run(
         "app:app", host=settings.host, port=settings.port, reload=settings.app_reload

src/jbi/configuration.py renamed to src/app/configuration.py

@@ -31,8 +31,3 @@ def get_actions(
         except ValidationError as exception:
             logger.exception(exception)
             raise ConfigError("Errors exist.") from exception
-
-
-def get_actions_dict():
-    """Returns dict of `get_actions()`"""
-    return get_actions().dict()["actions"]

src/app/monitor.py

@@ -7,7 +7,7 @@
 from fastapi.responses import JSONResponse
 
 from src.app import environment
-from src.jbi.services import jbi_service_health_map, jira_visible_projects
+from src.jbi.services import jbi_service_health_map
 
 api_router = APIRouter(tags=["Monitor"])
 
@@ -62,9 +62,3 @@ def head_lbheartbeat(request: Request):
 def version():
     """Return version.json, as required by Dockerflow."""
     return environment.get_version()
-
-
-@api_router.get("/jira_projects/")
-def get_jira_projects():
-    """API for viewing projects that are currently accessible by API"""
-    return jira_visible_projects()

src/jbi/bugzilla.py

@@ -6,11 +6,14 @@
 import datetime
 import json
 import logging
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 from urllib.parse import ParseResult, urlparse
 
 from pydantic import BaseModel  # pylint: disable=no-name-in-module
 
+from src.jbi.errors import ActionNotFoundError
+from src.jbi.models import Action, Actions
+
 logger = logging.getLogger(__name__)
 
 JIRA_HOSTNAMES = ("jira", "atlassian")
@@ -200,6 +203,15 @@ def extract_from_see_also(self):
 
         return None
 
+    def lookup_action(self, actions: Actions) -> Tuple[str, Action]:
+        """Find first matching action from bug's whiteboard list"""
+        tags: List[str] = self.get_potential_whiteboard_config_list()
+        for tag in tags:
+            tag = tag.lower()
+            if action := actions.get(tag):
+                return tag, action
+        raise ActionNotFoundError(", ".join(tags))
+
 
 class BugzillaWebhookRequest(BaseModel):
     """Bugzilla Webhook Request Object"""

src/jbi/errors.py

@@ -1,6 +1,10 @@
 """Custom exceptions for JBI"""
 
 
+class ActionNotFoundError(Exception):
+    """No Action could be found for this bug"""
+
+
 class IgnoreInvalidRequestError(Exception):
     """Error thrown when requests are invalid and ignored"""
 

src/jbi/models.py

@@ -1,16 +1,17 @@
 """
 Python Module for Pydantic Models and validation
 """
+import functools
 import importlib
 from inspect import signature
 from types import ModuleType
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Mapping, Optional
 
 from pydantic import Extra, root_validator, validator
 from pydantic_yaml import YamlModel
 
 
-class Action(YamlModel, extra=Extra.allow):
+class Action(YamlModel):
     """
     Action is the inner model for each action in the configuration file"""
 
@@ -19,6 +20,13 @@ class Action(YamlModel, extra=Extra.allow):
     allow_private: bool = False
     parameters: dict = {}
 
+    @functools.cached_property
+    def callable(self) -> Callable:
+        """Return the initialized callable for this action."""
+        action_module: ModuleType = importlib.import_module(self.action)
+        initialized: Callable = action_module.init(**self.parameters)  # type: ignore
+        return initialized
+
     @root_validator
     def validate_action_config(
         cls, values
@@ -40,13 +48,27 @@ def validate_action_config(
             raise ValueError("action is not properly setup.") from exception
         return values
 
+    class Config:
+        """Pydantic configuration"""
+
+        extra = Extra.allow
+        keep_untouched = (functools.cached_property,)
+
 
 class Actions(YamlModel):
     """
     Actions is the overall model for the list of `actions` in the configuration file
     """
 
-    actions: Dict[str, Action]
+    actions: Mapping[str, Action]
+
+    def get(self, tag: Optional[str]) -> Optional[Action]:
+        """Lookup actions by whiteboard tag"""
+        return self.actions.get(tag.lower()) if tag else None
+
+    def all(self):
+        """Return mapping of all actions"""
+        return self.actions
 
     @validator("actions")
     def validate_action_matches_whiteboard(