Refactoring & portable Testpfade

logseq-install.sh

@@ -7,18 +7,26 @@
 # KONSTANTEN UND KONFIGURATION
 # =============================================================================
 
+# Farb-Codes für die Terminal-Ausgabe
 readonly COLOR_RED=$(tput setaf 1)
 readonly COLOR_GREEN=$(tput setaf 2)
 readonly COLOR_YELLOW=$(tput setaf 3)
 readonly COLOR_RESET=$(tput sgr0)
+
+# Standardwerte
 readonly ALLOW_ROOT_DEFAULT=false
 
+# Pfad-Konstanten
 readonly INSTALL_DIR="${HOME}/.local/bin"
 readonly DESKTOP_DIR="${HOME}/.local/share/applications"
+readonly SYMLINK_PATH="${INSTALL_DIR}/Logseq"
+
+# URLs
 readonly LOGO_URL="https://raw.githubusercontent.com/logseq/logseq/master/resources/icons/logseq.png"
 readonly RELEASE_API_URL="https://github.com/logseq/logseq/releases/latest"
 readonly DOWNLOAD_BASE_URL="https://github.com/logseq/logseq/releases/download"
 
+# Dateinamen-Muster
 readonly APP_NAME="Logseq"
 readonly APP_IMAGE_PATTERN="Logseq-linux-x64-*.AppImage"
 readonly DESKTOP_FILE="${DESKTOP_DIR}/logseq.desktop"
@@ -37,9 +45,10 @@ FILENAME_LOGSEQ=""
 # FEHLERBEHANDLUNG
 # =============================================================================
 
-# Fehlerbehandlung für unbehandelte Fehler
+# ERR-Trap: Wird bei jedem unbehandelten Befehlsfehler aktiviert
 trap 'handle_error' ERR
 
+# Wird durch die ERR-Trap bei unbehandelten Fehlern aufgerufen
 handle_error() {
     local exit_code=$?
     err "Ein unerwarteter Fehler ist aufgetreten (Exit-Code: ${exit_code})"
@@ -50,32 +59,36 @@ handle_error() {
     exit "${exit_code}"
 }
 
-# Ausgabe von Fehlermeldungen und Beenden
+# =============================================================================
+# AUSGABE-HELPER
+# =============================================================================
+
+# Gibt eine Fehlermeldung in Rot aus und beendet das Skript mit Code 1
 err() {
     echo "${COLOR_RED}$*${COLOR_RESET}" >&2
     exit 1
 }
 
-# Ausgabe von Warnungen
+# Gibt eine Warnung in Gelb auf stderr aus (ohne Abbruch)
 warn() {
     echo "${COLOR_YELLOW}$*${COLOR_RESET}" >&2
 }
 
-# Ausgabe von Erfolgsmeldungen
+# Gibt eine Erfolgsmeldung in Grün aus
 success() {
     echo "${COLOR_GREEN}$*${COLOR_RESET}"
 }
 
-# Ausgabe von Info-Meldungen
+# Gibt eine Info-Meldung aus (ohne Farbcode)
 info() {
     echo "$*"
 }
 
 # =============================================================================
-# HILFSFUNKTIONEN
+# ALLGEMEINE HILFSFUNKTIONEN
 # =============================================================================
 
-# Zeigt das Logo an
+# Zeigt das ASCII-Logo an
 show_logo() {
     echo -n "${COLOR_GREEN}"
     cat <<-'EOT'
@@ -99,12 +112,15 @@ show_logo() {
     echo -n "${COLOR_RESET}"
 }
 
-# Zeigt die Hilfe an
+# Zeigt die Hilfe an; optional wird vorher eine Fehlermeldung ausgegeben
 show_help() {
-    [[ $# -gt 0 ]] && echo "$*" && echo ""
+    if [[ $# -gt 0 ]]; then
+        echo "$*"
+        echo ""
+    fi
 
     cat <<-EOT
-	Logseq Installer
+	${APP_NAME} Installer
 	================
 	Erlaubte Optionen:
 
@@ -118,19 +134,20 @@ show_help() {
     exit 1
 }
 
-# Prüft, ob ein Befehl verfügbar ist
+# Stellt sicher, dass ein benötigter Befehl verfügbar ist
 require_command() {
     local cmd="$1"
     command -v "${cmd}" >/dev/null 2>&1 || err "Befehl '${cmd}' nicht gefunden. Bitte installieren Sie ${cmd}."
 }
 
 # =============================================================================
-# VERSIONEN-ERMITTELN
+# VERSIONSERMITTLUNG
 # =============================================================================
 
 # Ermittelt die neueste verfügbare Version von GitHub
 get_latest_version() {
     info "Ermittle neueste verfügbare Version..."
+    # Release-Seite abrufen und Versionsnummer aus dem Redirect-Link extrahieren
     VERSION_LATEST=$(
         wget -qO- "${RELEASE_API_URL}" |
         grep -Po 'releases/tag/\K\d+\.\d+\.\d+' |
@@ -140,15 +157,25 @@ get_latest_version() {
     success "Neueste Version: ${VERSION_LATEST}"
 }
 
-# Ermittelt die aktuell installierte Version
+# Ermittelt die aktuell installierte Version anhand des neuesten AppImage
 get_current_version() {
     info "Ermittle installierte Version..."
     local latest_appimage
-    latest_appimage=$(find "${INSTALL_DIR}" -maxdepth 1 -name "${APP_IMAGE_PATTERN}" -type f -printf '%T@ %p\n' 2>/dev/null | sort -n | tail -n1 | cut -d' ' -f2-)
+    # Neueste AppImage-Datei nach Änderungszeitpunkt (mtime) bestimmen
+    latest_appimage=$(
+        find "${INSTALL_DIR}" -maxdepth 1 -name "${APP_IMAGE_PATTERN}" -type f -printf '%T@ %p\n' 2>/dev/null |
+        sort -n |
+        tail -n1 |
+        cut -d' ' -f2-
+    )
 
     if [[ -n "${latest_appimage}" ]]; then
         VERSION_CURRENT=$(basename "${latest_appimage}" | grep -Po 'Logseq-linux-x64-\K\d+\.\d+\.\d+' | head -n1)
-        [[ -n "${VERSION_CURRENT}" ]] && success "Installierte Version: ${VERSION_CURRENT}" || warn "Installierte Version konnte nicht bestimmt werden."
+        if [[ -n "${VERSION_CURRENT}" ]]; then
+            success "Installierte Version: ${VERSION_CURRENT}"
+        else
+            warn "Installierte Version konnte nicht bestimmt werden."
+        fi
     else
         VERSION_CURRENT=""
         info "Logseq ist nicht installiert."
@@ -156,57 +183,55 @@ get_current_version() {
 }
 
 # =============================================================================
-# INSTALLATION
+# INSTALLATION & AKTUALISIERUNG
 # =============================================================================
 
 # Lädt die neueste Version herunter und installiert sie
 download_and_install() {
     local download_url="${DOWNLOAD_BASE_URL}/${VERSION_LATEST}/Logseq-linux-x64-${VERSION_LATEST}.AppImage"
     local tmp_file
-    tmp_file=$(mktemp)
 
     info "Lade Logseq ${VERSION_LATEST} herunter..."
     mkdir -p "${INSTALL_DIR}"
 
+    # Temp-Datei im Installationsverzeichnis anlegen, damit mv kein Dateisystem-Wechsel benötigt
+    tmp_file=$(mktemp -p "${INSTALL_DIR}")
+
     wget --show-progress -qO "${tmp_file}" "${download_url}" || err "Download fehlgeschlagen."
 
     FILENAME_LOGSEQ=$(basename "${download_url}")
-    mv "${tmp_file}" "${INSTALL_DIR}/${FILENAME_LOGSEQ}" || err "Verschieben der Datei fehlgeschlagen."
+    mv -f "${tmp_file}" "${INSTALL_DIR}/${FILENAME_LOGSEQ}" || err "Verschieben der Datei fehlgeschlagen."
     chmod u+x "${INSTALL_DIR}/${FILENAME_LOGSEQ}" || err "Berechtigungen setzen fehlgeschlagen."
 
-    # Alte Versionen entfernen
+    # Alte Versionen entfernen und Symlink auf die neue Version aktualisieren
     cleanup_old_versions
-
+    ln -sf "${INSTALL_DIR}/${FILENAME_LOGSEQ}" "${SYMLINK_PATH}" || err "Symlink erstellen fehlgeschlagen."
-    # Symlink erstellen/aktualisieren
-    ln -sf "${INSTALL_DIR}/${FILENAME_LOGSEQ}" "${INSTALL_DIR}/Logseq" || err "Symlink erstellen fehlgeschlagen."
     success "Logseq ${VERSION_LATEST} erfolgreich installiert."
 }
 
-# Entfernt alte AppImage-Versionen
+# Entfernt alte AppImage-Versionen bis auf die aktuell installierte
 cleanup_old_versions() {
     local current_file="${INSTALL_DIR}/${FILENAME_LOGSEQ}"
+    # Alle AppImages außer der aktuellen Datei löschen
     find "${INSTALL_DIR}" -maxdepth 1 -name "${APP_IMAGE_PATTERN}" -type f ! -path "${current_file}" -delete 2>/dev/null || true
-
-    # Alten Symlink entfernen falls vorhanden
-    [[ -L "${INSTALL_DIR}/Logseq" ]] && rm -f "${INSTALL_DIR}/Logseq"
 }
 
-# Erstellt die Desktop-Datei
+# Erstellt den Desktop-Eintrag für das Startmenü
 create_desktop_entry() {
     info "Erstelle Desktop-Eintrag..."
 
     # Icon herunterladen falls nicht vorhanden
-    [[ -f "${ICON_FILE}" ]] || {
+    if [[ ! -f "${ICON_FILE}" ]]; then
         info "Lade Icon herunter..."
         wget -qO "${ICON_FILE}" "${LOGO_URL}" || warn "Icon konnte nicht heruntergeladen werden."
-    }
+    fi
 
     cat > "${DESKTOP_FILE}" <<-EOF
 	[Desktop Entry]
 	Encoding=UTF-8
 	Name=Logseq
 	Comment=Wissensmanagement mit Logseq
-	Exec=${HOME}/.local/bin/${FILENAME_LOGSEQ} --no-sandbox
+	Exec=${INSTALL_DIR}/${FILENAME_LOGSEQ} --no-sandbox
 	Icon=${ICON_FILE}
 	Type=Application
 	Categories=Office;
@@ -222,21 +247,65 @@ create_desktop_entry() {
 uninstall_logseq() {
     info "Deinstalliere Logseq..."
 
-    rm -f "${INSTALL_DIR}/Logseq"*
+    # AppImage(s) und Symlink entfernen
-    rm -f "${DESKTOP_DIR}/logseq."*
+    rm -f "${SYMLINK_PATH}"
+    rm -f "${INSTALL_DIR}"/Logseq-linux-x64-*.AppImage
+
+    # Desktop-Eintrag und Icon entfernen
+    rm -f "${DESKTOP_FILE}" "${ICON_FILE}"
+
     update-desktop-database "${DESKTOP_DIR}" 2>/dev/null || true
 
     success "Logseq wurde vollständig deinstalliert."
     exit 0
 }
 
-# Prüft ob Logseq läuft
+# Prüft, ob Logseq gerade läuft (Update nur bei beendeter Instanz)
 check_running() {
-    if pgrep -ifcx "${INSTALL_DIR}/Logseq" >/dev/null; then
+    # pgrep-Flags: -i (case-insensitive), -f (volle Kommandozeile),
+    # -c (Anzahl Treffer), -x (exakte Übereinstimmung der Kommandozeile)
+    if pgrep -ifcx "${SYMLINK_PATH}" >/dev/null; then
         err "Logseq läuft noch. Bitte beenden Sie Logseq vor dem Update."
     fi
 }
 
+# =============================================================================
+# KOMMANDOZEILEN-ARGUMENTE & ROOT-PRÜFUNG
+# =============================================================================
+
+# Parst Kommandozeilenargumente (kurz und lang)
+parse_arguments() {
+    local optspec=":her-:"
+    local OPT OPTARG
+
+    while getopts "${optspec}" OPT; do
+        [[ "${OPT}" == " " ]] && continue
+
+        # Lange Option (--wort oder --wort=wert) auflösen
+        if [[ "${OPT}" == "-" ]]; then
+            OPT="${OPTARG%%=*}"
+            OPTARG="${OPTARG#"${OPT}"}"
+            OPTARG="${OPTARG#=}"
+        fi
+
+        case "${OPT}" in
+            h | hilfe)      show_help ;;
+            e | entfernen)  uninstall_logseq ;;
+            r | root)       ALLOW_ROOT=true ;;
+            \?)             show_help "Unbekannte Option: -${OPTARG}" ;;
+            *)              show_help "Unbekannte Option: --${OPT}" ;;
+        esac
+    done
+    shift $((OPTIND - 1))
+}
+
+# Verhindert die Ausführung als root, außer wenn explizit erlaubt
+check_root_permissions() {
+    if [[ "$(whoami)" == "root" && "${ALLOW_ROOT}" == "false" ]]; then
+        show_help "Die Installation sollte nicht als root erfolgen (Option -r/--root erlaubt es)."
+    fi
+}
+
 # =============================================================================
 # MAIN
 # =============================================================================
@@ -280,41 +349,8 @@ main() {
     success "Logseq wurde erfolgreich installiert/aktualisiert."
 }
 
-# Parst Kommandozeilenargumente
-parse_arguments() {
-    local optspec=":her-:"
-    local OPT OPTARG
-
-    while getopts "${optspec}" OPT; do
-        [[ "${OPT}" == " " ]] && continue
-
-        if [[ "${OPT}" == "-" ]]; then
-            OPT="${OPTARG%%=*}"
-            OPTARG="${OPTARG#"${OPT}"}"
-            OPTARG="${OPTARG#=}"
-        fi
-
-        case "${OPT}" in
-            h | hilfe)      show_help ;;
-            e | entfernen)  uninstall_logseq ;;
-            r | root)       ALLOW_ROOT=true ;;
-            \?)             show_help "Unbekannte Option: -${OPTARG}" ;;
-            *)              show_help "Unbekannte Option: --${OPT}" ;;
-        esac
-    done
-    shift $((OPTIND - 1))
-}
-
-# Prüft Root-Berechtigungen
-check_root_permissions() {
-    if [[ "$(whoami)" == "root" && "${ALLOW_ROOT}" == "false" ]]; then
-        show_help "Die Installation sollte nicht als root erfolgen (Option -r/--root erlaubt es)."
-        exit 1
-    fi
-}
-
 # =============================================================================
-# LETS GO
+# EINSTIEGSPUNKT
 # =============================================================================
 
-main "$@"
+main "$@"

run-tests.sh

@@ -29,17 +29,8 @@ fi
 # Mocks ausführbar machen
 chmod +x "${TEST_DIR}/mocks/"*
 
-# Test-Fixtures prüfen
+# Test-Fixtures werden on-the-fly in den Tests erstellt (über VERSION_* Variablen)
-if [[ ! -f "${TEST_DIR}/fixtures/Logseq-linux-x64-0.10.15.AppImage" ]]; then
+# Daher ist hier keine statische Vorbereitung mehr nötig.
-    echo -e "${YELLOW}Erstelle Test-Fixtures...${NC}"
-    for ver in 0.10.14 0.10.15 0.10.16; do
-        {
-            echo "#!/bin/bash"
-            echo "echo \"Logseq ${ver} dummy\""
-        } > "${TEST_DIR}/fixtures/Logseq-linux-x64-${ver}.AppImage"
-        chmod +x "${TEST_DIR}/fixtures/Logseq-linux-x64-${ver}.AppImage"
-    done
-fi
 
 echo -e "${YELLOW}Führe Tests aus...${NC}"
 echo

test/README.md

@@ -72,11 +72,25 @@ Jeder Mock liest seine Konfiguration aus einer State-Datei in `fixtures/`.
 Die Tests können diese States über Hilfsfunktionen setzen:
 
 ```bash
-set_wget_latest_version "0.10.16"    # Neueste Version simulieren
+set_wget_latest_version "${VERSION_LATEST}"     # Neueste Version simulieren
-set_find_installed_version "0.10.14" # Installierte Version simulieren
+set_find_installed_version "${VERSION_INSTALLED}"  # Installierte Version simulieren
-set_pgrep_running 1                   # Prozess läuft (1) oder nicht (0)
+set_pgrep_running 1                              # Prozess läuft (1) oder nicht (0)
 ```
 
+## Versions-Variablen
+
+Versionsnummern sind **nicht hartkodiert** in den Tests, sondern als Variablen
+am Anfang der Testdatei definiert. Dummy-AppImages werden on-the-fly erstellt:
+
+```bash
+VERSION_LATEST="0.10.15"      # Neueste verfügbare Version
+VERSION_INSTALLED="0.10.14"   # Ältere installierte Version
+VERSION_OUTDATED="0.10.13"    # Noch ältere Version (für Cleanup-Tests)
+```
+
+Um die Tests an eine neue Version anzupassen, reicht es, diese drei Variablen
+zu ändern. Die Dummy-AppImages und State-Dateien werden automatisch angepasst.
+
 ## Neuen Test hinzufügen
 
 In `test/logseq-installer.bats`:
@@ -84,7 +98,7 @@ In `test/logseq-installer.bats`:
 ```bash
 @test "mein neuer Test" {
     # Mock-States setzen
-    set_wget_latest_version "0.10.16"
+    set_wget_latest_version "${VERSION_LATEST}"
     set_find_installed_version ""
     set_pgrep_running 0
 

test/fixtures/Logseq-linux-x64-0.10.13.AppImage

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Logseq 0.10.13 dummy"

test/fixtures/wget_state

@@ -1,3 +1,3 @@
 WGET_LATEST_VERSION="0.10.15"
 WGET_DOWNLOAD_SUCCESS="true"
-WGET_DOWNLOAD_FILE="${FIXTURES_DIR}/Logseq-linux-x64-0.10.15.AppImage"
+WGET_DOWNLOAD_FILE="Logseq-linux-x64-0.10.15.AppImage"

test/logseq-installer.bats

@@ -3,8 +3,27 @@
 # Test-Suite für logseq-install.sh
 # Verwendet Mocks für wget, pgrep, find, update-desktop-database
 
-# Test-Setup
+# =============================================================================
+# VERSIONS-KONSTANTEN (nur hier ändern, Tests passen sich automatisch an)
+# =============================================================================
+# Version, die als "neueste" von GitHub gemeldet wird
+VERSION_LATEST="0.10.15"
+# Version, die als bereits installiert simuliert wird (älter als LATEST)
+VERSION_INSTALLED="0.10.14"
+# Noch ältere Version für Cleanup-Tests (mehrere alte Versionen)
+VERSION_OUTDATED="0.10.13"
+
+# =============================================================================
+# TEST-SETUP / TEARDOWN
+# =============================================================================
+
 setup() {
+    # Pfade relativ zur Testdatei ableiten (funktioniert unabhängig vom Ablageort)
+    # BATS_TEST_DIRNAME zeigt immer auf das Verzeichnis der .bats-Datei.
+    export MOCKS_DIR="${BATS_TEST_DIRNAME}/mocks"
+    export FIXTURES_DIR="${BATS_TEST_DIRNAME}/fixtures"
+    export SCRIPT_PATH="${BATS_TEST_DIRNAME}/../logseq-install.sh"
+
     # Test-Verzeichnis
     export TEST_DIR="$(mktemp -d)"
     export HOME="${TEST_DIR}/home"
@@ -12,63 +31,79 @@ setup() {
     export DESKTOP_DIR="${HOME}/.local/share/applications"
 
     # Mock-PATH vorbereiten (Mocks vor echten Befehlen)
-    export PATH="/home/tim/Dokumente/Sourcen/Logseq-Installer/test/mocks:${PATH}"
+    export PATH="${MOCKS_DIR}:${PATH}"
-
-    # Fixtures-Verzeichnis
-    export FIXTURES_DIR="/home/tim/Dokumente/Sourcen/Logseq-Installer/test/fixtures"
 
     # Home-Verzeichnis erstellen
-    mkdir -p "${HOME}"
+    mkdir -p "${HOME}" "${INSTALL_DIR}" "${DESKTOP_DIR}"
-    mkdir -p "${INSTALL_DIR}"
+
-    mkdir -p "${DESKTOP_DIR}"
+    # Dummy-AppImages für alle benötigten Versionen on-the-fly erstellen
+    create_dummy_appimage "${VERSION_LATEST}"
+    create_dummy_appimage "${VERSION_INSTALLED}"
+    create_dummy_appimage "${VERSION_OUTDATED}"
 
     # Mock-States zurücksetzen
     reset_mocks
 }
 
-# Test-Cleanup
 teardown() {
     rm -rf "${TEST_DIR}"
 }
 
-# Mock-States zurücksetzen
+# =============================================================================
+# HELPER-FUNKTIONEN
+# =============================================================================
+
+# Erzeugt ein Dummy-AppImage für eine bestimmte Version (falls nicht vorhanden)
+create_dummy_appimage() {
+    local version="$1"
+    local file="${FIXTURES_DIR}/Logseq-linux-x64-${version}.AppImage"
+    if [[ ! -f "${file}" ]]; then
+        {
+            echo "#!/bin/bash"
+            echo "echo \"Logseq ${version} dummy\""
+        } > "${file}"
+        chmod +x "${file}"
+    fi
+}
+
+# Mock-States auf Default zurücksetzen
 reset_mocks() {
-    # wget: neueste Version 0.10.15
+    set_wget_latest_version "${VERSION_LATEST}"
-    cat > "${FIXTURES_DIR}/wget_state" <<'EOF'
+    set_wget_download_success "true"
-WGET_LATEST_VERSION="0.10.15"
+    set_pgrep_running 0
-WGET_DOWNLOAD_SUCCESS="true"
+    set_find_installed_version ""
-WGET_DOWNLOAD_FILE="${FIXTURES_DIR}/Logseq-linux-x64-0.10.15.AppImage"
-EOF
-
-    # pgrep: kein Prozess läuft
-    cat > "${FIXTURES_DIR}/pgrep_state" <<'EOF'
-PGREP_MATCH_COUNT=0
-EOF
-
-    # find: nichts installiert
-    cat > "${FIXTURES_DIR}/find_state" <<'EOF'
-FIND_INSTALLED_VERSION=""
-FIND_FILES_RAW=""
-EOF
 }
 
-# Hilfsfunktion: Mock-State für wget setzen
+# Mock-State für wget: neueste Version setzen
 set_wget_latest_version() {
+    local version="$1"
+    create_dummy_appimage "${version}"
     cat > "${FIXTURES_DIR}/wget_state" <<EOF
-WGET_LATEST_VERSION="${1}"
+WGET_LATEST_VERSION="${version}"
-WGET_DOWNLOAD_SUCCESS="true"
+WGET_DOWNLOAD_SUCCESS="${WGET_DOWNLOAD_SUCCESS:-true}"
-WGET_DOWNLOAD_FILE="${FIXTURES_DIR}/Logseq-linux-x64-${1}.AppImage"
+WGET_DOWNLOAD_FILE="Logseq-linux-x64-${version}.AppImage"
 EOF
 }
 
-# Hilfsfunktion: Mock-State für pgrep setzen
+# Mock-State für wget: Download-Erfolg steuern
+set_wget_download_success() {
+    WGET_DOWNLOAD_SUCCESS="$1"
+    # State-Datei neu schreiben mit aktuellem Erfolgswert
+    cat > "${FIXTURES_DIR}/wget_state" <<EOF
+WGET_LATEST_VERSION="${VERSION_LATEST}"
+WGET_DOWNLOAD_SUCCESS="${1}"
+WGET_DOWNLOAD_FILE="Logseq-linux-x64-${VERSION_LATEST}.AppImage"
+EOF
+}
+
+# Mock-State für pgrep: Prozess läuft (1) oder nicht (0)
 set_pgrep_running() {
     cat > "${FIXTURES_DIR}/pgrep_state" <<EOF
 PGREP_MATCH_COUNT=${1}
 EOF
 }
 
-# Hilfsfunktion: Mock-State für find setzen (installierte Version)
+# Mock-State für find: installierte Version setzen
 set_find_installed_version() {
     cat > "${FIXTURES_DIR}/find_state" <<EOF
 FIND_INSTALLED_VERSION="${1}"
@@ -76,7 +111,7 @@ FIND_FILES_RAW=""
 EOF
 }
 
-# Hilfsfunktion: Mock-State für find setzen (mehrere Dateien)
+# Mock-State für find: mehrere Dateien setzen (pipe-getrennt)
 set_find_files() {
     cat > "${FIXTURES_DIR}/find_state" <<EOF
 FIND_INSTALLED_VERSION=""
@@ -84,12 +119,19 @@ FIND_FILES_RAW="${1}"
 EOF
 }
 
+# Erzeugt eine echte Dummy-AppImage-Datei im Installationsverzeichnis
+create_installed_appimage() {
+    local version="$1"
+    local file="${INSTALL_DIR}/Logseq-linux-x64-${version}.AppImage"
+    touch "${file}"
+    chmod +x "${file}"
+}
+
 # Das Skript mit Test-Umgebung ausführen
 run_installer() {
-    # Umgebungsvariablen für das Skript setzen
     HOME="${HOME}" \
     PATH="${PATH}" \
-    /home/tim/Dokumente/Sourcen/Logseq-Installer/logseq-install.sh "$@"
+    "${SCRIPT_PATH}" "$@"
 }
 
 # =============================================================================
@@ -124,7 +166,6 @@ run_installer() {
 }
 
 @test "root-Option ohne Root-Rechte wird akzeptiert" {
-    # Nicht als root, aber -r angegeben -> sollte nicht fehlschlagen
     run run_installer -r --hilfe
     [ "$status" -eq 1 ]  # Hilfe wird angezeigt
     [[ "$output" == *"Logseq Installer"* ]]
@@ -135,8 +176,7 @@ run_installer() {
 # =============================================================================
 
 @test "uninstall entfernt Dateien und exited mit 0" {
-    # Dummy-Dateien erstellen
+    create_installed_appimage "${VERSION_INSTALLED}"
-    touch "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage"
     touch "${INSTALL_DIR}/Logseq"
     touch "${DESKTOP_DIR}/logseq.desktop"
     touch "${DESKTOP_DIR}/logseq.png"
@@ -145,8 +185,7 @@ run_installer() {
     [ "$status" -eq 0 ]
     [[ "$output" == *"deinstalliert"* ]]
 
-    # Dateien sollten weg sein
+    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_INSTALLED}.AppImage" ]
-    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage" ]
     [ ! -f "${INSTALL_DIR}/Logseq" ]
     [ ! -f "${DESKTOP_DIR}/logseq.desktop" ]
     [ ! -f "${DESKTOP_DIR}/logseq.png" ]
@@ -157,25 +196,18 @@ run_installer() {
 # =============================================================================
 
 @test "get_latest_version ermittelt Version aus GitHub" {
-    # Wir testen die Funktion indirekt durch den Hauptablauf
-    # aber hier prüfen wir, ob wget-Mock korrekt funktioniert
     run run_installer --hilfe
     [ "$status" -eq 1 ]
 }
 
 @test "get_current_version erkennt installierte Version" {
-    set_find_installed_version "0.10.14"
+    set_find_installed_version "${VERSION_INSTALLED}"
-
-    # Simuliere Installation durch direkten Aufruf (wir testen intern)
-    # Da wir Funktionen nicht direkt testen können, testen wir über den Hauptablauf
-    # mit --hilfe nur als Dummy - eigentlicher Test passiert in Integrationstests
     run run_installer --hilfe
     [ "$status" -eq 1 ]
 }
 
 @test "get_current_version erkennt keine Installation" {
     set_find_installed_version ""
-
     run run_installer --hilfe
     [ "$status" -eq 1 ]
 }
@@ -185,55 +217,37 @@ run_installer() {
 # =============================================================================
 
 @test "Installation: neueste Version wird heruntergeladen und installiert" {
-    # Setup: Version 0.10.15 ist neueste, nichts installiert
+    set_wget_latest_version "${VERSION_LATEST}"
-    set_wget_latest_version "0.10.15"
     set_find_installed_version ""
-
-    # Mock: pgrep sagt, kein Prozess läuft
     set_pgrep_running 0
 
     run run_installer
     [ "$status" -eq 0 ]
-    [[ "$output" == *"erfolgreich installiert"* ]] || [[ "$output" == *"erfolgreich"* ]]
+    [[ "$output" == *"erfolgreich"* ]]
 
-    # AppImage sollte existieren
+    [ -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_LATEST}.AppImage" ]
-    [ -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.15.AppImage" ]
-
-    # Symlink sollte existieren
     [ -L "${INSTALL_DIR}/Logseq" ]
-    [ "$(readlink "${INSTALL_DIR}/Logseq")" = "${INSTALL_DIR}/Logseq-linux-x64-0.10.15.AppImage" ]
+    [ "$(readlink "${INSTALL_DIR}/Logseq")" = "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_LATEST}.AppImage" ]
-
-    # Desktop-Datei sollte existieren
     [ -f "${DESKTOP_DIR}/logseq.desktop" ]
 }
 
 @test "Update: alte Version wird durch neue ersetzt" {
-    # Setup: 0.10.14 installiert, 0.10.15 verfügbar
+    set_find_installed_version "${VERSION_INSTALLED}"
-    set_find_installed_version "0.10.14"
+    set_wget_latest_version "${VERSION_LATEST}"
-    set_wget_latest_version "0.10.15"
     set_pgrep_running 0
-
+    create_installed_appimage "${VERSION_INSTALLED}"
-    # Dummy-Datei für alte Version
-    touch "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage"
-    chmod +x "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage"
 
     run run_installer
     [ "$status" -eq 0 ]
 
-    # Neue Version installiert
+    [ -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_LATEST}.AppImage" ]
-    [ -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.15.AppImage" ]
+    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_INSTALLED}.AppImage" ]
-
+    [ "$(readlink "${INSTALL_DIR}/Logseq")" = "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_LATEST}.AppImage" ]
-    # Alte Version gelöscht
-    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage" ]
-
-    # Symlink zeigt auf neue Version
-    [ "$(readlink "${INSTALL_DIR}/Logseq")" = "${INSTALL_DIR}/Logseq-linux-x64-0.10.15.AppImage" ]
 }
 
 @test "Kein Update: bereits aktuelle Version beendet mit Code 0" {
-    # Setup: 0.10.15 installiert, 0.10.15 verfügbar
+    set_find_installed_version "${VERSION_LATEST}"
-    set_find_installed_version "0.10.15"
+    set_wget_latest_version "${VERSION_LATEST}"
-    set_wget_latest_version "0.10.15"
 
     run run_installer
     [ "$status" -eq 0 ]
@@ -241,10 +255,9 @@ run_installer() {
 }
 
 @test "Abbruch: Logseq läuft noch" {
-    # Setup: Prozess läuft
     set_pgrep_running 1
-    set_find_installed_version "0.10.14"
+    set_find_installed_version "${VERSION_INSTALLED}"
-    set_wget_latest_version "0.10.15"
+    set_wget_latest_version "${VERSION_LATEST}"
 
     run run_installer
     [ "$status" -eq 1 ]
@@ -252,13 +265,7 @@ run_installer() {
 }
 
 @test "Fehler: Download fehlschlägt" {
-    # Setup: Download fehlschlägt
+    set_wget_download_success "false"
-    cat > "${FIXTURES_DIR}/wget_state" <<'EOF'
-WGET_LATEST_VERSION="0.10.15"
-WGET_DOWNLOAD_SUCCESS="false"
-WGET_DOWNLOAD_FILE="${FIXTURES_DIR}/Logseq-linux-x64-0.10.15.AppImage"
-EOF
-
     set_find_installed_version ""
     set_pgrep_running 0
 
@@ -272,7 +279,7 @@ EOF
 # =============================================================================
 
 @test "Desktop-Datei wird korrekt erstellt" {
-    set_wget_latest_version "0.10.15"
+    set_wget_latest_version "${VERSION_LATEST}"
     set_find_installed_version ""
     set_pgrep_running 0
 
@@ -282,25 +289,22 @@ EOF
     desktop_file="${DESKTOP_DIR}/logseq.desktop"
     [ -f "${desktop_file}" ]
 
-    # Inhalt prüfen
     grep -q "Name=Logseq" "${desktop_file}"
-    grep -q "Exec=${HOME}/.local/bin/Logseq-linux-x64-0.10.15.AppImage --no-sandbox" "${desktop_file}"
+    grep -q "Exec=${HOME}/.local/bin/Logseq-linux-x64-${VERSION_LATEST}.AppImage --no-sandbox" "${desktop_file}"
     grep -q "Icon=${DESKTOP_DIR}/logseq.png" "${desktop_file}"
     grep -q "Categories=Office;" "${desktop_file}"
 }
 
 @test "Icon wird heruntergeladen wenn nicht vorhanden" {
-    set_wget_latest_version "0.10.15"
+    set_wget_latest_version "${VERSION_LATEST}"
     set_find_installed_version ""
     set_pgrep_running 0
 
-    # Icon nicht vorhanden
     [ ! -f "${DESKTOP_DIR}/logseq.png" ]
 
     run run_installer
     [ "$status" -eq 0 ]
 
-    # Icon sollte jetzt da sein
     [ -f "${DESKTOP_DIR}/logseq.png" ]
 }
 
@@ -309,13 +313,7 @@ EOF
 # =============================================================================
 
 @test "Root-Check: als root ohne -r Option schlägt fehl" {
-    # Simuliere root durch Überschreiben von whoami
+    run grep -q "whoami.*root" "${SCRIPT_PATH}"
-    # Wir können whoami nicht einfach mocken, aber wir können testen
-    # dass die Logik im Skript stimmt indem wir den Code prüfen
-    # (Integrationstest würde sudo erfordern)
-    
-    # Prüfen dass der Code die Prüfung enthält
-    run grep -q "whoami.*root" /home/tim/Dokumente/Sourcen/Logseq-Installer/logseq-install.sh
     [ "$status" -eq 0 ]
 }
 
@@ -324,24 +322,19 @@ EOF
 # =============================================================================
 
 @test "Cleanup: mehrere alte Versionen werden entfernt" {
-    # Setup: mehrere alte Versionen vorhanden
+    set_find_files "Logseq-linux-x64-${VERSION_OUTDATED}.AppImage|Logseq-linux-x64-${VERSION_INSTALLED}.AppImage"
-    set_find_files "Logseq-linux-x64-0.10.13.AppImage|Logseq-linux-x64-0.10.14.AppImage"
+    set_wget_latest_version "${VERSION_LATEST}"
-    set_wget_latest_version "0.10.15"
     set_pgrep_running 0
 
-    # Dateien erstellen
+    create_installed_appimage "${VERSION_OUTDATED}"
-    touch "${INSTALL_DIR}/Logseq-linux-x64-0.10.13.AppImage"
+    create_installed_appimage "${VERSION_INSTALLED}"
-    touch "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage"
-    chmod +x "${INSTALL_DIR}/Logseq-linux-x64-0.10.13.AppImage"
-    chmod +x "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage"
 
     run run_installer
     [ "$status" -eq 0 ]
 
-    # Nur neue Version da
+    [ -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_LATEST}.AppImage" ]
-    [ -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.15.AppImage" ]
+    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_OUTDATED}.AppImage" ]
-    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.13.AppImage" ]
+    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-${VERSION_INSTALLED}.AppImage" ]
-    [ ! -f "${INSTALL_DIR}/Logseq-linux-x64-0.10.14.AppImage" ]
 }
 
 # =============================================================================
@@ -349,8 +342,7 @@ EOF
 # =============================================================================
 
 @test "Farbcodes werden gesetzt (tput)" {
-    # Prüfen dass tput-Codes im Skript sind
+    run grep -q "tput setaf" "${SCRIPT_PATH}"
-    run grep -q "tput setaf" /home/tim/Dokumente/Sourcen/Logseq-Installer/logseq-install.sh
     [ "$status" -eq 0 ]
 }
 
@@ -359,11 +351,11 @@ EOF
 # =============================================================================
 
 @test "Fehlerbehandlung: Trap für ERR gesetzt" {
-    run grep -q "trap.*handle_error.*ERR" /home/tim/Dokumente/Sourcen/Logseq-Installer/logseq-install.sh
+    run grep -q "trap.*handle_error.*ERR" "${SCRIPT_PATH}"
     [ "$status" -eq 0 ]
 }
 
 @test "require_command prüft Abhängigkeiten" {
-    run grep -q "require_command" /home/tim/Dokumente/Sourcen/Logseq-Installer/logseq-install.sh
+    run grep -q "require_command" "${SCRIPT_PATH}"
     [ "$status" -eq 0 ]
 }

test/mocks/find

@@ -3,7 +3,7 @@
 # - Bei Versions-Erkennung: simulierte Pfade aus State
 # - Bei Cleanup mit -delete: echte Dateien löschen
 
-MOCK_DIR="/home/tim/Dokumente/Sourcen/Logseq-Installer/test/fixtures"
+MOCK_DIR="$(cd "$(dirname "$0")/../fixtures" && pwd)"
 MOCK_STATE_FILE="${MOCK_DIR}/find_state"
 # Echten find über absoluten Pfad aufrufen (vermeidet Rekursion über PATH)
 REAL_FIND=""

test/mocks/pgrep

@@ -2,7 +2,7 @@
 # Mock für pgrep - steuert Prozess-Erkennung
 # pgrep -c: gibt Anzahl aus, Exit-Code 0 wenn >0, sonst 1
 
-MOCK_DIR="/home/tim/Dokumente/Sourcen/Logseq-Installer/test/fixtures"
+MOCK_DIR="$(cd "$(dirname "$0")/../fixtures" && pwd)"
 MOCK_STATE_FILE="${MOCK_DIR}/pgrep_state"
 
 if [[ -f "${MOCK_STATE_FILE}" ]]; then

test/mocks/wget

@@ -1,7 +1,7 @@
 #!/bin/bash
 # Mock für wget - simuliert GitHub API und Downloads
 
-MOCK_DIR="$(dirname "$0")/../fixtures"
+MOCK_DIR="$(cd "$(dirname "$0")/../fixtures" && pwd)"
 MOCK_STATE_FILE="${MOCK_DIR}/wget_state"
 
 # State laden (welche Version soll zurückgegeben werden?)
@@ -15,6 +15,11 @@ WGET_LATEST_VERSION="${WGET_LATEST_VERSION:-0.10.15}"
 WGET_DOWNLOAD_SUCCESS="${WGET_DOWNLOAD_SUCCESS:-true}"
 WGET_DOWNLOAD_FILE="${WGET_DOWNLOAD_FILE:-${MOCK_DIR}/Logseq-linux-x64-0.10.15.AppImage}"
 
+# Relativen Download-Pfad gegen das Fixtures-Verzeichnis auflösen (portable State-Dateien)
+if [[ "${WGET_DOWNLOAD_FILE}" != /* ]]; then
+    WGET_DOWNLOAD_FILE="${MOCK_DIR}/${WGET_DOWNLOAD_FILE}"
+fi
+
 case "$*" in
     *releases/latest*)
         # Simuliere GitHub Release-Seite