Refactor conftest.py: Move to integration directory and use pytest hooks

- Move tests/conftest.py to tests/integration/conftest.py for better scope
- Replace fixture-based setup with pytest_sessionstart/sessionfinish hooks
- Setup containers BEFORE test names are printed for cleaner output
- Add devcontainer protection (vsc-*, _devcontainer suffix) in cleanup logic
- Implement selenium container reuse between test runs for faster execution
- Add health checking for existing containers with automatic recovery
- Separate cleanup logic: app containers removed, selenium kept for reuse
- Add environment variables: APP_LEAVE_RUNNING, SELENIUM_LEAVE_RUNNING

Author: ilude

.devcontainer/Makefile

@@ -15,6 +15,17 @@ initialize:
 	@echo "SEMANTIC_VERSION=$(SEMANTIC_VERSION)" >> .devcontainer/.env
 
 
+
+# One-step container setup invoked by devcontainer postCreateCommand
+setup-container:
+	@echo "Running entrypoint scripts..."
+	@for script in .devcontainer/entrypoint.d/*.sh; do \
+			echo "Running $$script"; \
+			bash "$$script" || echo "entrypoint script failed: $$script"; \
+	done
+	@echo "Entrypoint scripts completed."
+
+
 # Install development dependencies (only if pyproject.toml changed)
 uv.lock:
 	uv lock

.devcontainer/devcontainer.json

@@ -20,7 +20,7 @@
     }
   },
   "initializeCommand": "make initialize",
-  "postCreateCommand": "sudo chown -R ${USER}:${USER} ${PROJECT_PATH} && uv sync --dev && ./.devcontainer/setup-dotfiles.sh",
+  "postCreateCommand": "make setup-container",
   "runArgs": [
     "--name","${localWorkspaceFolderBasename}_devcontainer",
     "--hostname","${localWorkspaceFolderBasename}",

.devcontainer/setup-dotfiles.sh renamed to .devcontainer/entrypoint.d/01-dotfiles-setup.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -o errexit   # abort on nonzero exitstatus
+set -o nounset   # abort on unbound variable
+set -o pipefail  # don't hide errors within pipes
+# set -x # Uncomment for debugging
+
+sudo chown -R ${USER}:${USER} ${PROJECT_PATH}
+sudo chown -R ${USER}:${USER} ${HOME}
+sudo chown -R ${USER}:${USER} /var/run/docker.sock
+
+uv sync --dev

.devcontainer/entrypoint.d/20-project-setup.sh

@@ -40,10 +40,10 @@
 		"date +%F": true,
 		"ls": true,
 		"/^uv run (pytest|black|isort|behave|python).*/": true,
-    "uv sync": true,
+    "/^uv sync .*/": true,
     "/^make (?:run|format|lint|test(?:-[\\w-]+)?)$/": true,
 		"/^git (add|log|status|show\\b.*).*/": true,
-		"docker build": true,
+		"/^docker (build|inspect|logs|ps).*/": true,
 		"behave": true
 	},
 

.vscode/settings.json

@@ -67,32 +67,42 @@ RUN sed -i 's/UID_MAX .*/UID_MAX    100000/' /etc/login.defs && \
 
 COPY --chmod=755 <<-"EOF" /usr/local/bin/docker-entrypoint.sh
 #!/bin/bash
-set -o errexit   # abort on nonzero exitstatus
-set -o nounset   # abort on unbound variable
-set -o pipefail  # do not hide errors within pipes
-if [ -v DOCKER_ENTRYPOINT_DEBUG ] && [ "$DOCKER_ENTRYPOINT_DEBUG" == 1 ]; then
+# Bash entrypoint: use bash for richer debugging and reliable `pipefail` support.
+# Use strict flags that are bash-compatible.
+set -euo pipefail
+if [ "${DOCKER_ENTRYPOINT_DEBUG:-}" = "1" ]; then
     set -x
-    set -o xtrace
 fi
 
 # If running as root, adjust the ${USER} user's UID/GID and drop to that user
 if [ "$(id -u)" = "0" ]; then
     groupmod -o -g ${PGID:-1000} ${USER} 2>&1 >/dev/null|| true
     usermod -o -u ${PUID:-1000} ${USER} 2>&1 >/dev/null|| true
 
-    # Ensure docker.sock is owned by the target user when running as root
-    chown ${USER}:${USER} /var/run/docker.sock >/dev/null 2>&1 || true
-    chown -R ${USER}:${USER} ${PROJECT_PATH}
+    # Run optional devcontainer entrypoint hooks if present. Development-only
+    # scripts placed in ${PROJECT_PATH}/.devcontainer/entrypoint.d/ will be
+    # executed here at container start. Production images don't include this
+    # directory so changes there won't affect production image layer caching.
+    if [ -d "${PROJECT_PATH}/.devcontainer/entrypoint.d" ]; then
+        for hook in "${PROJECT_PATH}"/.devcontainer/entrypoint.d/*.sh; do
+            if [ -f "$hook" ]; then
+                echo "devcontainer hook START: $hook at $(date) PID=$$"
+                set +e # Allow the hook to fail without aborting startup
+                bash "$hook"
+                rc=$?
+                set -e
+                echo "devcontainer hook FINISH: $hook at $(date) rc=${rc}"
+            fi
+        done
+    fi
+
+    # Ensure project path ownership for the runtime user
+    # Only touch the docker socket if it exists (socket or file) - one-liner
+    ( [ -S /var/run/docker.sock ] || [ -e /var/run/docker.sock ] ) && chown ${USER}:${USER} /var/run/docker.sock || true
+    chown -R ${USER}:${USER} ${PROJECT_PATH} || true
 
     echo "Running as user ${USER}: $@"
     exec gosu ${USER} "$@"
-else
-    # If not running as root, attempt to chown docker.sock using sudo if available
-    if command -v sudo >/dev/null 2>&1; then
-        sudo chown ${USER}:${USER} /var/run/docker.sock >/dev/null 2>&1 || true
-        sudo chown -R ${USER}:${USER} ${HOME}
-        sudo chown -R ${USER}:${USER} ${PROJECT_PATH}
-    fi
 fi
 
 echo "Running: $@"
@@ -255,7 +265,7 @@ RUN --mount=type=cache,target=/tmp/.cache/uv \
     --mount=type=cache,target=/root/.cache/pip \
     --mount=type=cache,target=/root/.cache/uv \
     uv sync --dev && \
-    chown -R $USER:$USER /usr/local/lib/python3.12/site-packages/ && \
+    chown -R $USER:$USER /usr/local/lib/python*/site-packages/ && \
     chown -R $USER:$USER /usr/local/bin
 
 

Dockerfile

@@ -1,6 +1,7 @@
 import json
 import logging
 import os
+import time
 
 from app.models.utils import pwd
 from app.services.favicon_store import FaviconStore
@@ -42,10 +43,62 @@ def bookmarks_list(self, bookmarks, urls=[]):
 
     def reload(self):
         logger.debug("Beginning Bookmark Bar reload...")
-        with open(self.bookmark_bar_path, "r") as file:
-            self._bar = json.load(file)
-        self.last_reload = self.mtime
 
-        self.favicon_store.fetch_favicons_from(self.bookmarks_list(self._bar))
+        try:
+            # Read file content first so we can back it up if parsing fails
+            with open(self.bookmark_bar_path, "r", encoding="utf-8") as file:
+                content = file.read()
 
-        logger.debug("Completed Bookmark Bar reload!")
+            try:
+                new_bar = json.loads(content)
+            except json.JSONDecodeError as e:
+                # Backup the corrupt file for inspection and keep previous bar in memory
+                logger.error("Failed to parse bookmark bar JSON: %s", e)
+                try:
+                    backup_path = f"{self.bookmark_bar_path}.corrupt.{int(time.time())}"
+                    with open(backup_path, "w", encoding="utf-8") as bf:
+                        bf.write(content)
+                    logger.warning(
+                        "Backed up corrupt bookmarks file to %s", backup_path
+                    )
+                except Exception as be:
+                    logger.exception("Failed to write corrupt backup file: %s", be)
+
+                if hasattr(self, "_bar") and self._bar:
+                    logger.info(
+                        "Keeping previous bookmark bar in memory after parse failure."
+                    )
+                    # Don't update last_reload so is_modified remains True until a valid file is present
+                    return
+                else:
+                    logger.info(
+                        "No previous bookmark bar available; falling back to empty list."
+                    )
+                    new_bar = []
+
+            # Assign the parsed content and update mtime
+            self._bar = new_bar
+            self.last_reload = self.mtime
+
+            # Fetch favicons but don't let favicon failures crash the app
+            try:
+                self.favicon_store.fetch_favicons_from(self.bookmarks_list(self._bar))
+            except Exception:
+                logger.exception("Failed to fetch favicons during bookmark bar reload")
+
+            logger.debug("Completed Bookmark Bar reload!")
+
+        except FileNotFoundError:
+            logger.warning(
+                "Bookmark bar file not found at %s; using empty bar",
+                self.bookmark_bar_path,
+            )
+            # Ensure we have a bar to render
+            if not hasattr(self, "_bar") or self._bar is None:
+                self._bar = []
+            self.last_reload = 0
+        except Exception:
+            # Catch-all to prevent reload failures from bubbling up into requests
+            logger.exception("Unexpected error while reloading bookmark bar")
+            if not hasattr(self, "_bar") or self._bar is None:
+                self._bar = []