feat: Created a separate 'ssl' property for the config so users don't have to specify an ssl_cert_path to use SSL or use the uri workaround for HTTPS API access

Hotfix and feature adds for some new issues

.actrc

@@ -0,0 +1,4 @@
+--artifact-server-path=./.act/artifacts
+--cache-server-path=./.act/cache
+--container-options --privileged
+--env ACT=true

.cargo-husky/hooks/pre-commit

@@ -4,8 +4,8 @@ set -e
 
 echo "Running pre-push hook:"
 
-echo "Executing: make lint"
+echo "Executing: cargo fmt"
-make lint
+cargo fmt
 
-echo "Executing: cargo test"
+echo "Executing: cargo clippy --all"
-cargo test
+cargo clippy --all

.cargo-husky/hooks/pre-push

@@ -4,8 +4,11 @@ set -e
 
 echo "Running pre-push hook:"
 
-echo "Executing: make lint"
+echo "Executing: cargo fmt --check"
-make lint
+cargo fmt --check
 
-echo "Executing: cargo test"
+echo "Executing: cargo clippy --all"
-cargo test
+cargo clippy --all
+
+echo "Executing: cargo test --all"
+cargo test --all

.cz.toml

@@ -0,0 +1,10 @@
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "v$version"
+version_scheme = "semver"
+version_provider = "cargo"
+update_changelog_on_bump = true
+major_version_zero = true
+
+[tool.commitizen.hooks]
+pre-commit = "git add Cargo.toml Cargo.lock"

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: Dark-Alex-17

.github/PULL_REQUEST_TEMPLATE/pull_request_template.md

@@ -0,0 +1,11 @@
+### AI assistance (if any):
+- List tools here and files touched by them
+
+### Authorship & Understanding
+
+- [ ] I wrote or heavily modified this code myself
+- [ ] I understand how it works end-to-end
+- [ ] I can maintain this code in the future
+- [ ] No undisclosed AI-generated code was used
+- [ ] If AI assistance was used, it is documented below
+

.github/workflows/check.yml

@@ -11,8 +11,6 @@ name: Check
 env:
   CARGO_TERM_COLOR: always
 
-# ensure that the workflow is only triggered once per PR, subsequent pushes to the PR will cancel
-# and restart the workflow. See https://docs.github.com/en/actions/using-jobs/using-concurrency
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
@@ -24,14 +22,18 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt
+
       - name: Run cargo fmt
         run: cargo fmt -- --check
+
       - name: Cache Cargo dependencies
         uses: Swatinem/rust-cache@v2
+
   clippy:
     name: ${{ matrix.toolchain }} / clippy
     runs-on: ubuntu-latest
@@ -45,12 +47,15 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
+
       - name: Run clippy action
         uses: clechasseur/rs-clippy-check@v3
+
       - name: Cache Cargo dependencies
         uses: Swatinem/rust-cache@v2
   doc:
@@ -61,21 +66,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+
       - name: Install Rust nightly
         uses: dtolnay/rust-toolchain@nightly
+
       - name: Run cargo doc
         run: cargo doc --no-deps --all-features
         env:
           RUSTDOCFLAGS: --cfg docsrs
   msrv:
     # check that we can build using the minimal rust version that is specified by this crate
-    name: 1.82.0 / check
+    name: 1.89.0 / check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Install 1.82.0
+
+      - name: Install 1.89.0
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.82.0
+          toolchain: 1.89.0
-      - name: cargo +1.82.0 check
+
+      - name: cargo +1.89.0 check
         run: cargo check

.github/workflows/release.yml

@@ -1,32 +1,688 @@
-# Adapted from https://github.com/joshka/github-workflows/blob/main/.github/workflows/rust-release-plz.yml
+name: Create release
-# Thanks to joshka for permission to use this template!
-
-name: Create Release PR and publish to crates.io
 
 permissions:
   pull-requests: write
   contents: write
 
 on:
-  push:
+  workflow_dispatch:
-    branches:
+    inputs:
-      - main
+      bump_type:
+        description: 'Specify the type of version bump'
+        required: true
+        default: 'patch'
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
 
 jobs:
-  release-plz:
+  bump-version:
-    # see https://release-plz.ieni.dev/docs/github
+    name: bump-version
-    # for more information
-    name: Release-plz
     runs-on: ubuntu-latest
     steps:
+      - name: Configure SSH for Git
+        if: env.ACT != 'true'
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.RELEASE_BOT_SSH_KEY }}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keyscan -H github.com >> ~/.ssh/known_hosts
+
+      - name: Checkout repository
+        if: env.ACT != 'true'
+        uses: actions/checkout@v3
+        with:
+          ssh-key: ${{ secrets.RELEASE_BOT_SSH_KEY }}
+          fetch-depth: 0
+
+      - name: Checkout repository
+        if: env.ACT == 'true'
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Install Commitizen
+        run: |
+          python3 -m pip install --upgrade pip
+          pip3 install commitizen==4.8.3
+          npm install -g conventional-changelog-cli
+
+      - name: Configure Git user
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Bump version with Commitizen
+        run: |
+          cz bump --yes --increment ${{ github.event.inputs.bump_type }}
+
+      - name: Amend commit message to include '[skip ci]'
+        run: |
+          git commit --amend --no-edit -m "$(git log -1 --pretty=%B) [skip ci]"
+
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Get the new version tag
+        id: version
+        run: |
+          mkdir -p artifacts
+          NEW_TAG=$(cz version --project)
+          echo "New version: $NEW_TAG"
+          echo "version=$NEW_TAG" >> $GITHUB_ENV
+          echo "$NEW_TAG" > artifacts/release-version
+
+      - name: Get the previous version tag
+        id: prev_version
+        run: |
+          PREV_TAG=$(git describe --tags --abbrev=0 ${GITHUB_SHA}^)
+          echo "Previous tag: $PREV_TAG"
+          echo "prev_version=$PREV_TAG" >> $GITHUB_ENV
+
+      - name: Bump Cargo.toml version
+        shell: bash
+        working-directory: ${{ github.workspace }}
+        env:
+          VERSION: ${{ env.version }}
+        run: |
+          set -euo pipefail
+          : "${VERSION:?env.version is empty}"
+
+          # Ignore Act's local artifact dir noise
+          echo artifacts/ >> .git/info/exclude || true
+
+          # Edit the version line right after name="managarr"
+          sed -E -i '
+            /^[[:space:]]*name[[:space:]]*=[[:space:]]*"managarr"[[:space:]]*$/ {
+              n
+              s|^[[:space:]]*version[[:space:]]*=[[:space:]]*"[^"]*"|version = "'"$VERSION"'"|
+            }
+          ' Cargo.toml
+
+          cargo update || true
+
+          # Git config that helps in containers (Act)
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+          # Debug: show what changed
+          git status --porcelain
+          git diff --name-only -- Cargo.toml Cargo.lock || true
+
+          # Only commit if one of these files actually changed
+          if ! git diff --quiet -- Cargo.toml Cargo.lock; then
+            # Stage only modifications of already tracked files (won't pick up artifacts/)
+            git add -u -- Cargo.toml Cargo.lock
+            git commit -m "chore: bump Cargo.toml to $VERSION"
+          else
+            echo "No changes to commit (already at $VERSION)"
+          fi
+
+      - name: Bump validate_theme_derive/Cargo.toml version
+        shell: bash
+        working-directory: ${{ github.workspace }}/proc_macros/validate_theme_derive
+        env:
+          VERSION: ${{ env.version }}
+        run: |
+          set -euo pipefail
+          : "${VERSION:?env.version is empty}"
+
+          # Ignore Act's local artifact dir noise
+          echo artifacts/ >> .git/info/exclude || true
+
+          # Edit the version line right after name="managarr"
+          sed -E -i '
+            /^[[:space:]]*name[[:space:]]*=[[:space:]]*"managarr"[[:space:]]*$/ {
+              n
+              s|^[[:space:]]*version[[:space:]]*=[[:space:]]*"[^"]*"|version = "'"$VERSION"'"|
+            }
+          ' Cargo.toml
+
+          cargo update || true
+
+          # Git config that helps in containers (Act)
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+          # Debug: show what changed
+          git status --porcelain
+          git diff --name-only -- Cargo.toml || true
+
+          # Only commit if one of these files actually changed
+          if ! git diff --quiet -- Cargo.toml; then
+            # Stage only modifications of already tracked files (won't pick up artifacts/)
+            git add -u -- Cargo.toml
+            git commit -m "chore: bump validate_theme_derive Cargo.toml to $VERSION"
+          else
+            echo "No changes to commit (already at $VERSION)"
+          fi
+
+      - name: Bump enum_display_style_derive/Cargo.toml version
+        shell: bash
+        working-directory: ${{ github.workspace }}/proc_macros/enum_display_style_derive
+        env:
+          VERSION: ${{ env.version }}
+        run: |
+          set -euo pipefail
+          : "${VERSION:?env.version is empty}"
+
+          # Ignore Act's local artifact dir noise
+          echo artifacts/ >> .git/info/exclude || true
+
+          # Edit the version line right after name="managarr"
+          sed -E -i '
+            /^[[:space:]]*name[[:space:]]*=[[:space:]]*"managarr"[[:space:]]*$/ {
+              n
+              s|^[[:space:]]*version[[:space:]]*=[[:space:]]*"[^"]*"|version = "'"$VERSION"'"|
+            }
+          ' Cargo.toml
+
+          cargo update || true
+
+          # Git config that helps in containers (Act)
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+          # Debug: show what changed
+          git status --porcelain
+          git diff --name-only -- Cargo.toml || true
+
+          # Only commit if one of these files actually changed
+          if ! git diff --quiet -- Cargo.toml; then
+            # Stage only modifications of already tracked files (won't pick up artifacts/)
+            git add -u -- Cargo.toml
+            git commit -m "chore: bump enum_display_style_derive Cargo.toml to $VERSION"
+          else
+            echo "No changes to commit (already at $VERSION)"
+          fi
+
+      - name: Generate changelog for the version bump
+        id: changelog
+        run: |
+          conventional-changelog -p angular -i CHANGELOG.md --from ${{ env.prev_version }} --to v${{ env.version }} > artifacts/changelog.md
+
+      - name: Push changes
+        if: env.ACT != 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git push origin --follow-tags
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Upload the changed Cargo files (Act)
+        if: env.ACT == 'true'
+        uses: actions/upload-artifact@v4
+        with:
+          name: bumped-cargo-files
+          path: |
+            Cargo.toml
+            Cargo.lock
+            proc_macros/validate_theme_derive/Cargo.toml
+            proc_macros/enum_display_style_derive/Cargo.toml
+
+  build-release-artifacts:
+    name: build-release
+    needs: [bump-version]
+    runs-on: ${{ matrix.job.os }}
+    env:
+      RUST_BACKTRACE: 1
+    strategy:
+      fail-fast: true
+      matrix:
+        # prettier-ignore
+        job:
+          - { name: "macOS-arm64",        os: "macOS-latest",   target: "aarch64-apple-darwin",           artifact_suffix: "macos-arm64",     use-cross: true                             }
+          - { name: "macOS-amd64",        os: "macOS-latest",   target: "x86_64-apple-darwin",            artifact_suffix: "macos"                                                        }
+          - { name: "windows-amd64",      os: "windows-latest", target: "x86_64-pc-windows-msvc",         artifact_suffix: "windows"                                                      }
+          - { name: "windows-aarch64",    os: "windows-latest", target: "aarch64-pc-windows-msvc",        artifact_suffix: "windows-aarch64", use-cross: true                             }
+          - { name: "linux-gnu",          os: "ubuntu-latest",  target: "x86_64-unknown-linux-gnu",       artifact_suffix: "linux"                                                        }
+          - { name: "linux-musl",         os: "ubuntu-latest",  target: "x86_64-unknown-linux-musl",      artifact_suffix: "linux-musl",      use-cross: true,                            }
+          - { name: "linux-aarch64-gnu",  os: "ubuntu-latest",  target: "aarch64-unknown-linux-gnu",      artifact_suffix: "aarch64-gnu",     use-cross: true, test-bin: "--bin managarr" }
+          - { name: "linux-aarch64-musl", os: "ubuntu-latest",  target: "aarch64-unknown-linux-musl",     artifact_suffix: "aarch64-musl",    use-cross: true, test-bin: "--bin managarr" }
+          - { name: "linux-arm-gnu",      os: "ubuntu-latest",  target: "arm-unknown-linux-gnueabi",      artifact_suffix: "armv6-gnu",       use-cross: true, test-bin: "--bin managarr" }
+          - { name: "linux-arm-musl",     os: "ubuntu-latest",  target: "arm-unknown-linux-musleabihf",   artifact_suffix: "armv6-musl",      use-cross: true, test-bin: "--bin managarr" }
+          - { name: "linux-armv7-gnu",    os: "ubuntu-latest",  target: "armv7-unknown-linux-gnueabihf",  artifact_suffix: "armv7-gnu",       use-cross: true, test-bin: "--bin managarr" }
+          - { name: "linux-armv7-musl",   os: "ubuntu-latest",  target: "armv7-unknown-linux-musleabihf", artifact_suffix: "armv7-musl",      use-cross: true, test-bin: "--bin managarr" }
+        rust: [stable]
+
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Ensure repository is up-to-date
+        if: env.ACT != 'true'
+        run: |
+          git fetch --all
+          git pull
+
+      - name: Get bumped Cargo files (Act)
+        if: env.ACT == 'true'
+        uses: actions/download-artifact@v4
+        with:
+          name: bumped-cargo-files
+          path: ${{ github.workspace }}
+
+      - uses: actions/cache@v3
+        name: Cache Cargo registry
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
+
+      - uses: actions/cache@v3
+        if: startsWith(matrix.job.name, 'linux-')
+        with:
+          path: ~/.cargo/bin
+          key: ${{ runner.os }}-cargo-bin-${{ hashFiles('.github/workflows/release.yml') }}
+
+      - uses: dtolnay/rust-toolchain@stable
+        name: Set Rust toolchain
+        with:
+          targets: ${{ matrix.job.target }}
+
+      - uses: taiki-e/setup-cross-toolchain-action@v1
+        with:
+          # NB: sets CARGO_BUILD_TARGET evar - do not need --target flag in build
+          target: ${{ matrix.job.target }}
+
+      - uses: taiki-e/install-action@cross
+        if: ${{ matrix.job.use-cross }}
+
+      - name: Installing needed Ubuntu dependencies
+        if: matrix.job.os == 'ubuntu-latest'
+        shell: bash
+        run: |
+          sudo apt-get -y update
+          case ${{ matrix.job.target }} in
+            arm*-linux-*) sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+            aarch64-*-linux-*) sudo apt-get -y install gcc-aarch64-linux-gnu ;;
+          esac
+
+      - name: Build
+        run: cargo build --release --verbose --target=${{ matrix.job.target }} --locked
+
+      - name: Verify file
+        shell: bash
+        run: |
+          file target/${{ matrix.job.target }}/release/managarr
+
+      - name: Test
+        if: matrix.job.target != 'aarch64-apple-darwin' && matrix.job.target != 'aarch64-pc-windows-msvc'
+        run: cargo test --release --verbose --target=${{ matrix.job.target }} ${{ matrix.job.test-bin }}
+
+      - name: Packaging final binary (Windows)
+        if: matrix.job.os == 'windows-latest'
+        shell: bash
+        run: |
+          cd target/${{ matrix.job.target }}/release
+          BINARY_NAME=managarr.exe
+          if [ "${{ matrix.job.target }}" != "aarch64-pc-windows-msvc" ]; then
+            # strip the binary
+            strip $BINARY_NAME
+          fi
+          RELEASE_NAME=managarr-${{ matrix.job.artifact_suffix }}
+          mkdir -p artifacts
+          tar czvf $RELEASE_NAME.tar.gz $BINARY_NAME
+          # create sha checksum files
+          certutil -hashfile $RELEASE_NAME.tar.gz sha256 | grep -E [A-Fa-f0-9]{64} > $RELEASE_NAME.sha256
+          echo "RELEASE_NAME=$RELEASE_NAME" >> $GITHUB_ENV
+
+      - name: Packaging final binary (macOS and Linux)
+        if: matrix.job.os != 'windows-latest'
+        shell: bash
+        run: |
+          # set the right strip executable
+          STRIP="strip";
+          case ${{ matrix.job.target }} in
+            arm*-linux-*) STRIP="arm-linux-gnueabihf-strip" ;;
+            aarch64-*-linux-*)    STRIP="aarch64-linux-gnu-strip" ;;
+          esac;
+          cd target/${{ matrix.job.target }}/release
+          BINARY_NAME=managarr
+          # strip the binary
+          "$STRIP" "$BINARY_NAME"
+          RELEASE_NAME=managarr-${{ matrix.job.artifact_suffix }}
+          tar czvf $RELEASE_NAME.tar.gz $BINARY_NAME
+          # create sha checksum files
+          shasum -a 256 $RELEASE_NAME.tar.gz > $RELEASE_NAME.sha256
+          echo "RELEASE_NAME=$RELEASE_NAME" >> $GITHUB_ENV
+
+      - name: Add artifacts
+        run: |
+          mkdir -p artifacts
+          cp target/${{ matrix.job.target }}/release/${{ env.RELEASE_NAME }}.tar.gz artifacts/
+          cp target/${{ matrix.job.target }}/release/${{ env.RELEASE_NAME }}.sha256 artifacts/
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-${{ env.RELEASE_NAME }}
+          path: artifacts
+          overwrite: true
+
+  publish-github-release:
+    name: publish-github-release
+    needs: [build-release-artifacts]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Ensure repository is up-to-date
+        if: env.ACT != 'true'
+        run: |
+          git fetch --all
+          git pull
+
+      - name: Set environment variables
+        run: |
+          release_version="$(cat ./artifacts/release-version)"
+          echo "RELEASE_VERSION=$release_version" >> $GITHUB_ENV
+
+      - name: Validate release environment variables
+        run: |
+          echo "Release version: ${{ env.RELEASE_VERSION }}"
+          echo "Changelog body: $(cat artifacts/changelog.md)"
+
+      - name: Create a GitHub Release
+        if: env.ACT != 'true'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          files: |
+            artifacts/managarr-macos-arm64.tar.gz
+            artifacts/managarr-macos-arm64.sha256
+            artifacts/managarr-macos.tar.gz
+            artifacts/managarr-macos.sha256
+            artifacts/managarr-windows.tar.gz
+            artifacts/managarr-windows.sha256
+            artifacts/managarr-windows-aarch64.tar.gz
+            artifacts/managarr-windows-aarch64.sha256
+            artifacts/managarr-linux.tar.gz
+            artifacts/managarr-linux.sha256
+            artifacts/managarr-linux-musl.tar.gz
+            artifacts/managarr-linux-musl.sha256
+            artifacts/managarr-aarch64-gnu.tar.gz
+            artifacts/managarr-aarch64-gnu.sha256
+            artifacts/managarr-aarch64-musl.tar.gz
+            artifacts/managarr-aarch64-musl.sha256
+            artifacts/managarr-armv6-gnu.tar.gz
+            artifacts/managarr-armv6-gnu.sha256
+            artifacts/managarr-armv6-musl.tar.gz
+            artifacts/managarr-armv6-musl.sha256
+            artifacts/managarr-armv7-gnu.tar.gz
+            artifacts/managarr-armv7-gnu.sha256
+            artifacts/managarr-armv7-musl.tar.gz
+            artifacts/managarr-armv7-musl.sha256
+          tag_name: v${{ env.RELEASE_VERSION }}
+          name: 'v${{ env.RELEASE_VERSION }}'
+          body_path: artifacts/changelog.md
+          draft: false
+          prerelease: false
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          path: artifacts
+          overwrite: true
+
+  publish-chocolatey-package:
+    needs: [publish-github-release]
+    name: Publish Chocolatey Package
+    runs-on: windows-latest
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Get release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Set release assets and version
+        shell: pwsh
+        run: |
+          # Read the first column from the SHA256 file
+          $windows_sha = Get-Content ./artifacts/managarr-windows.sha256 | ForEach-Object { $_.Split(' ')[0] }
+          Add-Content -Path $env:GITHUB_ENV -Value "WINDOWS_SHA=$windows_sha"
+
+          # Read the release version from the release-version file
+          $release_version = Get-Content ./artifacts/release-version
+          Add-Content -Path $env:GITHUB_ENV -Value "RELEASE_VERSION=$release_version"
+
+      - name: Validate release environment variables
+        run: |
+          echo "Release SHA windows: ${{ env.WINDOWS_SHA }}"
+          echo "Release version: ${{ env.RELEASE_VERSION }}"
+
+      - name: Package and Publish package to Chocolatey
+        if: env.ACT != 'true'
+        run: |
+          mkdir ./deployment/chocolatey/tools
+          # Run packaging script
+          python "./deployment/chocolatey/packager.py" ${{ env.RELEASE_VERSION }} "./deployment/chocolatey/managarr.nuspec.template" "./deployment/chocolatey/managarr.nuspec" ${{ env.WINDOWS_SHA }}
+          python "./deployment/chocolatey/packager.py" ${{ env.RELEASE_VERSION }} "./deployment/chocolatey/chocolateyinstall.ps1.template" "./deployment/chocolatey/tools/chocolateyinstall.ps1" ${{ env.WINDOWS_SHA }}
+
+          # Publish to Chocolatey
+          cd ./deployment/chocolatey
+          choco pack
+          echo y | choco install managarr -dv -s .
+          $version = managarr --version
+          $version = $version -replace " ", "."
+          choco push $version.nupkg -s https://push.chocolatey.org/ --api-key ${{ secrets.CHOCOLATEY_API_KEY }};
+
+  publish-homebrew-formula:
+    needs: [publish-github-release]
+    name: Update Homebrew formulas
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Get release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Set release assets and version
+        shell: bash
+        run: |
+          # Set environment variables
+          macos_sha="$(cat ./artifacts/managarr-macos.sha256 | awk '{print $1}')"
+          echo "MACOS_SHA=$macos_sha" >> $GITHUB_ENV
+          macos_sha_arm="$(cat ./artifacts/managarr-macos-arm64.sha256 | awk '{print $1}')"
+          echo "MACOS_SHA_ARM=$macos_sha_arm" >> $GITHUB_ENV
+          linux_sha="$(cat ./artifacts/managarr-linux-musl.sha256 | awk '{print $1}')"
+          echo "LINUX_SHA=$linux_sha" >> $GITHUB_ENV
+          release_version="$(cat ./artifacts/release-version)"
+          echo "RELEASE_VERSION=$release_version" >> $GITHUB_ENV
+
+      - name: Validate release environment variables
+        run: |
+          echo "Release SHA macos: ${{ env.MACOS_SHA }}"
+          echo "Release SHA macos-arm: ${{ env.MACOS_SHA_ARM }}"
+          echo "Release SHA linux musl: ${{ env.LINUX_SHA }}"
+          echo "Release version: ${{ env.RELEASE_VERSION }}"
+
+      - name: Execute Homebrew packaging script
+        if: env.ACT != 'true'
+        run: |
+          # run packaging script
+          python "./deployment/homebrew/packager.py" ${{ env.RELEASE_VERSION }} "./deployment/homebrew/managarr.rb.template" "./managarr.rb" ${{ env.MACOS_SHA }} ${{ env.MACOS_SHA_ARM }} ${{ env.LINUX_SHA }}
+
+      - name: Push changes to Homebrew tap
+        if: env.ACT != 'true'
+        env:
+          TOKEN: ${{ secrets.MANAGARR_GITHUB_TOKEN }}
+        run: |
+          # push to Git
+          git config --global user.name "Dark-Alex-17"
+          git config --global user.email "alex.j.tusa@gmail.com"
+          git clone https://Dark-Alex-17:${{ secrets.MANAGARR_GITHUB_TOKEN }}@github.com/Dark-Alex-17/homebrew-managarr.git
+          rm homebrew-managarr/Formula/managarr.rb
+          cp managarr.rb homebrew-managarr/Formula
+          cd homebrew-managarr
+          git add .
+          git diff-index --quiet HEAD || git commit -am "Update formula for Managarr release ${{ env.RELEASE_VERSION }}"
+          git push https://$TOKEN@github.com/Dark-Alex-17/homebrew-managarr.git
+
+  publish-docker-image:
+    needs: [publish-github-release]
+    name: Publishing Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Get release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Ensure repository is up-to-date
+        if: env.ACT != 'true'
+        run: |
+          git fetch --all
+          git pull
+
+      - name: Set version variable
+        run: |
+          version="$(cat artifacts/release-version)"
+          echo "version=$version" >> $GITHUB_ENV
+
+      - name: Validate release environment variables
+        run: |
+          echo "Release version: ${{ env.version }}"
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        if: env.ACT != 'true'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Push to Docker Hub
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: ${{ env.ACT != 'true' }}
+          tags: darkalex17/managarr:latest, darkalex17/managarr:${{ env.version }}
+
+  publish-crate:
+    needs: publish-github-release
+    name: Publish Crate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if actor is repository owner
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
+        run: |
+          echo "You are not authorized to run this workflow."
+          exit 1
+
       - name: Checkout
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+
+      - name: Get bumped Cargo files (Act)
+        if: env.ACT == 'true'
+        uses: actions/download-artifact@v4
+        with:
+          name: bumped-cargo-files
+          path: ${{ github.workspace }}
+
+      - name: Ensure repository is up-to-date
+        if: env.ACT != 'true'
+        run: |
+          git fetch --all
+          git pull
+
+      - uses: actions/cache@v3
+        name: Cache Cargo registry
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
+
+      - uses: actions/cache@v3
+        with:
+          path: ~/.cargo/bin
+          key: ${{ runner.os }}-cargo-bin-${{ hashFiles('.github/workflows/release.yml') }}
+
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
-      - name: Run release-plz
+
-        uses: MarcoIeni/release-plz-action@v0.5
+      - uses: katyo/publish-crates@v2
-        env:
+        if: env.ACT != 'true'
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/test.yml

@@ -34,55 +34,66 @@ jobs:
         toolchain: [stable, beta]
     steps:
       - uses: actions/checkout@v4
+
       - name: Install ${{ matrix.toolchain }}
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.toolchain }}
+
       # enable this ci template to run regardless of whether the lockfile is checked in or not
       - name: cargo generate-lockfile
         if: hashFiles('Cargo.lock') == ''
         run: cargo generate-lockfile
+
       - name: cargo test --locked
         run: cargo test --locked --all-features --all-targets
-  minimal-versions:
+
-    # This action chooses the oldest version of the dependencies permitted by Cargo.toml to ensure
+  # minimal-versions:
-    # that this crate is compatible with the minimal version that this crate and its dependencies
+  #   # This action chooses the oldest version of the dependencies permitted by Cargo.toml to ensure
-    # require. This will pickup issues where this create relies on functionality that was introduced
+  #   # that this crate is compatible with the minimal version that this crate and its dependencies
-    # later than the actual version specified (e.g., when we choose just a major version, but a
+  #   # require. This will pickup issues where this create relies on functionality that was introduced
-    # method was added after this version).
+  #   # later than the actual version specified (e.g., when we choose just a major version, but a
-    #
+  #   # method was added after this version).
-    # This particular check can be difficult to get to succeed as often transitive dependencies may
+  #   #
-    # be incorrectly specified (e.g., a dependency specifies 1.0 but really requires 1.1.5). There
+  #   # This particular check can be difficult to get to succeed as often transitive dependencies may
-    # is an alternative flag available -Zdirect-minimal-versions that uses the minimal versions for
+  #   # be incorrectly specified (e.g., a dependency specifies 1.0 but really requires 1.1.5). There
-    # direct dependencies of this crate, while selecting the maximal versions for the transitive
+  #   # is an alternative flag available -Zdirect-minimal-versions that uses the minimal versions for
-    # dependencies. Alternatively, you can add a line in your Cargo.toml to artificially increase
+  #   # direct dependencies of this crate, while selecting the maximal versions for the transitive
-    # the minimal dependency, which you do with e.g.:
+  #   # dependencies. Alternatively, you can add a line in your Cargo.toml to artificially increase
-    # ```toml
+  #   # the minimal dependency, which you do with e.g.:
-    # # for minimal-versions
+  #   # ```toml
-    # [target.'cfg(any())'.dependencies]
+  #   # # for minimal-versions
-    # openssl = { version = "0.10.55", optional = true } # needed to allow foo to build with -Zminimal-versions
+  #   # [target.'cfg(any())'.dependencies]
-    # ```
+  #   # openssl = { version = "0.10.55", optional = true } # needed to allow foo to build with -Zminimal-versions
-    # The optional = true is necessary in case that dependency isn't otherwise transitively required
+  #   # ```
-    # by your library, and the target bit is so that this dependency edge never actually affects
+  #   # The optional = true is necessary in case that dependency isn't otherwise transitively required
-    # Cargo build order. See also
+  #   # by your library, and the target bit is so that this dependency edge never actually affects
-    # https://github.com/jonhoo/fantoccini/blob/fde336472b712bc7ebf5b4e772023a7ba71b2262/Cargo.toml#L47-L49.
+  #   # Cargo build order. See also
-    # This action is run on ubuntu with the stable toolchain, as it is not expected to fail
+  #   # https://github.com/jonhoo/fantoccini/blob/fde336472b712bc7ebf5b4e772023a7ba71b2262/Cargo.toml#L47-L49.
-    runs-on: ubuntu-latest
+  #   # This action is run on ubuntu with the stable toolchain, as it is not expected to fail
-    name: ubuntu / stable / minimal-versions
+  #   runs-on: ubuntu-latest
-    steps:
+  #   name: ubuntu / stable / minimal-versions
-      - uses: actions/checkout@v4
+  #   steps:
-      - name: Install Rust stable
+  #     - uses: actions/checkout@v4
-        uses: dtolnay/rust-toolchain@stable
+
-      - name: Install nightly for -Zdirect-minimal-versions
+  #     - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@nightly
+  #       uses: dtolnay/rust-toolchain@stable
-      - name: rustup default stable
+
-        run: rustup default stable
+  #     - name: Install nightly for -Zdirect-minimal-versions
-      - name: cargo update -Zdirect-minimal-versions
+  #       uses: dtolnay/rust-toolchain@nightly
-        run: cargo +nightly update -Zdirect-minimal-versions
+
-      - name: cargo test
+  #     - name: rustup default stable
-        run: cargo test --locked --all-features --all-targets
+  #       run: rustup default stable
-      - name: Cache Cargo dependencies
+
-        uses: Swatinem/rust-cache@v2
+  #     - name: cargo update -Zdirect-minimal-versions
+  #       run: cargo +nightly update -Zdirect-minimal-versions
+
+  #     - name: cargo test
+  #       run: cargo test --locked --all-features --all-targets
+
+  #     - name: Cache Cargo dependencies
+  #       uses: Swatinem/rust-cache@v2
+
   os-check:
     # run cargo test on mac and windows
     runs-on: ${{ matrix.os }}
@@ -100,15 +111,20 @@ jobs:
       #   if: runner.os == 'Windows'
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
+
       - name: cargo generate-lockfile
         if: hashFiles('Cargo.lock') == ''
         run: cargo generate-lockfile
+
       - name: cargo test
         run: cargo test --locked --all-features --all-targets
+
       - name: Cache Cargo dependencies
         uses: Swatinem/rust-cache@v2
+
   coverage:
     # use llvm-cov to build and collect coverage and outputs in a format that
     # is compatible with codecov.io
@@ -136,22 +152,30 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
           components: llvm-tools-preview
+
       - name: cargo install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
+
       - name: cargo generate-lockfile
         if: hashFiles('Cargo.lock') == ''
         run: cargo generate-lockfile
+
       - name: cargo llvm-cov
         run: cargo llvm-cov --locked --all-features --lcov --output-path lcov.info
+
       - name: Record Rust version
         run: echo "RUST=$(rustc --version)" >> "$GITHUB_ENV"
+
       - name: Cache Cargo dependencies
         uses: Swatinem/rust-cache@v2
+
       - name: Upload to codecov.io
+        if: env.ACT != 'true'
         uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true

.gitignore

@@ -1,3 +1,4 @@
 /target
 /.idea/
 /.scannerwork/
+/.act/

.helix/config.toml

@@ -0,0 +1,5 @@
+[keys.normal.backspace]
+b = ":sh zellij run -x '4%%' --width '92%%' -f -n Build -- just build"
+r = ":sh zellij run -x '3%%' -y '8%%' --width '95%%' --height '90%%' -fc -n 'Run' -- just run"
+t = ":sh zellij run -x '4%%' --width '92%%' -f -n Tests -- just test"
+l = ":sh zellij run -x '4%%' --width '92%%' -f -n Lint -- just lint"

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+- hooks:
+  - id: commitizen
+  - id: commitizen-branch
+    stages:
+    - pre-push
+  repo: https://github.com/commitizen-tools/commitizen
+  rev: v3.30.0

CHANGELOG.md

@@ -5,7 +5,562 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## v0.7.1 (2026-02-04)
+
+### Feat
+
+- Added support for a system-wide notification popup mechanism that works across Servarrs
+- Implemented a 'config-path' command to print out the default Managarr configuration file path to help address #54
+- Full support for filtering disks and aggregating root folders in the UI's 'Stats' block
+- proper collapsing of root folder paths in the stats layer of the UI
+- Added config option to filter for specific disk space paths to display in the UI (CLI is unaffected)
+- Improved disk-space UI and CLI that shows the actual path being monitored instead of just a disk number
+- Implemented the forgotten lidarr list disk-space command
+
+### Fix
+
+- Improved the system notification feature so it can persist between modals
+- Sonarr API updated to somtimes allow either seeders or leechers to be null
+- Improved the first-time run behavior so that it outputs the default configuration file it tries to load to help users locate the file on first-runs
+- 'managarr config-path' should work without a pre-existing config already in place [#54]
+
+### Refactor
+
+- Removed the filtering of monitored_storage_paths from the networking module and migrated all of it to the UI
+
+## v0.7.0 (2026-01-21)
+
+### Feat
+
+- Blocklist support in Lidarr in both the CLI and TUI
+- CLI and TUI support for track history and track details in Lidarr
+- Lidarr UI support for album details popup
+- Implemented TUI handler support for the Album Details popup in Lidarr
+- Bulk added CLI support for tracks and album functionalities in Lidarr
+- Implemented the manual artist discography search tab in Lidarr's artist details UI
+- Lidarr CLI support for downloading a release
+- CLI support for searching for discography releases in Lidarr
+- Added TUI and CLI support for viewing Artist history in Lidarr
+- Full Lidarr system support for both the CLI and TUI
+- Full CLI and TUI support for the Lidarr Indexers tab
+- Full support for adding a root folder in Lidarr from both the CLI and TUI
+- naive lidarr root folder tab implementation. Needs improved add logic
+- Downloads tab support in Lidarr
+- Created a History tab in the Radarr UI and created a list history command and mark-history-item-as-failed command for Radarr
+- Implemented the Lidarr History tab and CLI support
+- TUI support for deleting a Lidarr album from the artist details popup
+- CLI support for deleting an album from Lidarr
+- Completed support for viewing Lidarr artist details
+- Full CLI and TUI support for adding an artist to Lidarr
+- Include the Lidarr artist disambiguation in the title of the Edit Artist popup
+- Initial Lidarr support for searching for new artists
+- Lidarr CLI commands to list quality profiles and metadata profiles
+- Improved CLI readability by creating a separate Global Options section for global flags
+- CLI support for deleting a tag in Lidarr
+- Lidarr CLI support for listing and adding tags
+- Added CLI and TUI support for editing Lidarr artists
+- Support for updating all Lidarr artists in both the CLI and TUI
+- Added Lidarr CLI support for fetching the host config and the security config
+- Created Lidarr commands: 'get artist-details' and 'get system-status'
+- Fetch the artist members as part of the artist details query
+- Support for toggling the monitoring of a given artist via the CLI and TUI
+- Full support for deleting an artist via CLI and TUI
+- TUI support for Lidarr library
+- CLI support for listing artists
+- Improved UI speed and responsiveness
+
+### Fix
+
+- Sonarr network wasn't checking for the user to be using the sorting block when populating season details
+- Sonarr CLI was not properly filtering out episode and season releases when manually searching for releases
+- Sonarr manual search TUI and CLI incorrectly displaying the same unfiltered results for both season and episode searches
+- Slowed down the automatic text scrolling in tables so the text is readable
+- Expanded the history item details size so that it can include all the available information for a given item; was previously being cut off on some screens
+- Bug in submitting the update series prompt in the series details UI in Sonarr
+- Don't include Lidarr artist disambiguation in Edit popup title when it is empty
+- Refactored how quality profiles, language profiles, and metadata profiles are populated for each servarr so they sort using the ID to mimic the web UI better
+- Added the correct keybinding context to the Lidarr edit artist popup
+- Improved fault tolerance for search result tables and test all indexer results tables
+- Prevented additional empty slice errors in indexer tables
+- Fixed a bug in all Servarr implementations to not try to get the current selection of a search table when an error is returned from the API
+- Fixed an issue with the Managarr table that would incorrectly try to display things before is_loading was ready
+- Fixed a bug where the edit collection popup would not display when opening it from collection details
+
+### Refactor
+
+- Refactored the SonarrEvent enum to not unnecessarily wrap dual series_id and season_number values in a tuple when both values can be passed directly
+- Improved and simplified the implementation of history details for both Sonarr and Lidarr
+- Let serde serialize Add Series and Add Movie enums instead of calling to_string up front
+- Use is_multiple_of for the tick counter in the UI module
+- Updated all model tests to use purpose-built assertions to improve readability and maintainability
+- Updated all handler tests to use purpose built assertions to improve readability and maintainability
+- Used is_multiple_of to make life easier and cleaner in the app module
+- Refactored all cli tests to use purpose-built assertions
+- Improved test assertions in the app module
+- Created dedicated proptests and assertions to clean up the handler unit tests
+- Migrated the handle_table_events macro into a trait for better IDE support, created a TableEventAdapter wrapper for the KeyEventHandlers to make it so that the trait can be used properly and a simple function to replace the previous call to the handle_table_events macro
+- Simplified both the table_handler macro and the stateful_table implementation
+- Improved error handling for the tail-logs subcommand to propagate errors up the stack instead of exiting there.
+- Added accessor methods to servarr_data structs, replaced for loops with functional iterator chains, eliminated mutable state tracking, and updated network module to use get_or_insert_default() for modal options
+- Improved error handling project-wide and cleaned up some regexes with unnecessary escapes (tail_logs and interpolate_env_vars)
+- Refactored to use more idiomatic let-else statements where applicable
+
+## v0.6.3 (2025-12-13)
+
+### Fix
+
+- Wrapped all Sonarr use of Language with Option to fix the 'null' array issue in the new Sonarr API
+
+## v0.6.2 (2025-12-12)
+
+### Fix
+
+- Fixed breaking Sonarr Episode file API calls after recent Sonarr API update
+
+### Refactor
+
+- Replaced all modulo usages of tick_until_poll with is_multiple_of
+
+## v0.6.1 (2025-09-02)
+
+### Fix
+
+- Fixed UI bugs introduced as part of the hotkey refactor
+
+### Refactor
+
+- Updated crate to publish properly with the procedural macros
+
+## v0.6.0 (2025-08-29)
+
+### Feat
+
+- Support for custom headers to be added to every request to each server to support alternative authentication mechanisms [#47]
+- Refactor all keybinding tips into a dynamically changing menu that can be invoked via '?' [#32]
+- Display total disk usage for series in the Library view to mirror Radarr functionality [#44]
+- Pagination support for jumping 20 items at a time in all table views [#45]
+- Support toggling Movie monitoring directly from the library view [#43]
+- Support toggling Movie monitoring from the CLI
+- Support toggling Series monitoring directly from the Sonarr library view [#43]
+- Support toggling Series monitoring from the CLI
+- Fixed the Radarr downloads tab to display more than 10 downloads at a time and added a new --count flag to the CLI for specifying the number of downloads to return
+- Fetch more than 10 downloads when listing Sonarr downloads, and add a --count flag to the CLI to specify how many downloads to fetch
+- Support alternative keymappings for all keys, featuring hjkl movements
+- Added the Eldritch theme and updated documentation
+- Write built in themes to the themes file on first run so users can define custom themes
+- Created a theme validation macro to verify theme configurations before allowing the TUI to start
+- Initial support for custom user-defined themes
+
+### Fix
+
+- Marked Radarr studios as nullable to prevent crashes
+- Fixed a bug where the Sonarr API was returning empty values for seeders when searching for season releases
+- Improve fault tolerance for tag associations in Radarr and Sonarr
+- Upgraded to the most recent version of Tokio to mitigate CWE-664
+- Updated all dependencies and updated openssl to the most recent version to mitigate CWE-416
+- Updated the name of the should_ignore_quit_key to ignore_special_keys_for_textbox_input to give a better idea of what the flag is used for; also added alt keybinding for backspace
+- Marked videoCodecs as Option to resolve #38
+- Marked the `Season.statistics` field as `Option` so that a panic does not happen for outdated Sonarr data. This resolves #35
+- When adding a film from the Collection Details modal, the render order was wrong: Radarr Library -> Collection Table -> Add Movie Prompt (missing the Collection details prompt too). Correct order is: Collection Table -> Collection Details Modal -> Add Movie Modal
+- Fixed a bug that was rendering encompassing blocks after other widgets were rendered, thus overwriting the custom styles on each previously rendered widget
+- change the name of the theme configuration file to 'themes'
+- Ensure key events are only processed on key press to avoid duplicates
+- Updated ring dependency to mitigate CWE-770
+- Modified the Sonarr DownloadRecord so that the episode_id is optional to prevent crashes for weird downloads
+
+### Refactor
+
+- Network module is now broken out into similar directory structures for each servarr to mimic the rest of the project to make it easier to develop and maintain
+- Refactored the IndexerTestResut model into the general Servarr models
+- Renamed 'ctrl-*' keyboard shortcuts to 'C-*' to simplify and shrink the on-screen help
+- Formatted files using rustfmt
+- Reformatted code to make the format checks pass
+- Created a derive macro for defining the display style of Enum models and removed the use of the EnumDisplayStyle trait
+- Expanded the serde_enum_from macro to further reduce code duplication
+
+## v0.5.1 (2025-03-01)
+
+### Feat
+
+- CLI Support for multiple Servarr instances
+- Support for multiple servarr definitions - no tests [skip ci]
+- Support for loading Servarr API tokens from a file
+- Tweaked the implementation for environment variables in the config a bit
+- var interpolation
+
+### Fix
+
+- Updated openssl to 0.10.70 to mitigate CVE-2025-24898
+- Addressed rustfmt complaints
+- Corrected typo in the managarr.nuspec.template
+
+### Refactor
+
+- Updated dependencies
+- Addressed Cargo fmt complaints
+- Added a debug line for logging to output the config used when starting Managarr
+- Updated the 2018 idiom lint to the 2021_compatibility lint
+- Removed unnecessary clones in the networking module to speed up network request handling
+- Corrected some clone instead of copy behaviors in the command line handlers
+- Removed unnecessary clone from stateful table
+- Removed unnecessary clone call from extract_and_add_tag_ids_vec method
+- Reduced the number of clones necessary when building modal structs
+- Refactored a handful of Option calls to use take instead
+- Renamed KeyEventHandler::with to KeyEventHandler::new to keep with Rust best practices and conventions
+
+## v0.4.2 (2024-12-21)
+
+### Fix
+
+- Revert failed release [skip ci]
+- **sonarr**: Pass the series ID alongside all UpdateAndScan events when publishing to the networking channel
+- **sonarr**: pass the series ID alongside all TriggerAutomaticSeriesSearch events when publishing to the networking channel
+- **sonarr**: Pass the series ID and season number alongside all TriggerAutomaticSeasonSearch events when publishing to the networking channel
+- **sonarr**: Pass the episode ID alongside all TriggerAutomaticEpisodeSearch events when publishing to the networking channel
+- **sonarr**: Pass the episode ID alongside all ToggleEpisodeMonitoring events when publishing to the networking channel
+- **sonarr**: Pass the series ID and season number alongside all toggle season monitoring events when publishing to the networking channel
+- **sonarr**: Pass the indexer ID directly alongside all TestIndexer events when publishing to the networking channel
+- **sonarr**: Provide the task name directly alongside all StartTask events when publishing to the networking channel
+- **sonarr**: Pass the search query directly to the networking channel when searching for a new series
+- **sonarr**: Pass the series ID alongside all GetSeriesHistory events when publishing to the networking channel
+- **sonarr**: Pass the series ID alongside all GetSeriesDetails events when publishing to the networking channel
+- **sonarr**: Pass series ID and season number alongside all ManualSeasonSearch events when publishing to the networking channel
+- **sonarr**: Provide the series ID and season number alongside all GetSeasonHistory events when publishing to the networking channel
+- **sonarr**: Pass the episode ID alongside all ManualEpisodeSearch events when publishing to the networking channel
+- **sonarr**: Pass events alongside all GetLogs events when publishing to the networking channel
+- **sonarr**: Pass the episode ID alongside all GetEpisodeHistory events when publishing to the networking channel
+- **sonarr**: Pass series ID alongside all GetEpisodeFiles events when publishing to the networking channel
+- **sonarr**: Pass series ID alognside all GetEpisodes events when publishing to the networking channel
+- **sonarr**: Pass the episode ID alongside all GetEpisodeDetails events when publishing to the networking channel
+- **sonarr**: Pass history events alongside all GetHistory events when publishing to the networking channel
+- **sonarr**: Construct and pass edit series parameters alongside all EditSeries events when publishing to the networking channel
+- **sonarr**: Construct and pass edit indexer parameters alongside all EditIndexer events when publishing to the networking channel
+- **sonarr**: Construct and pass edit all indexer settings alongside all EditAllIndexerSettings events when publishing to the networking channel
+- **sonarr**: Construct and pass delete series params alongside all DeleteSeries events when publishing to the networking channel
+- **sonarr**: Corrected a bug that would cause a crash if a user spams the ESC key while searching for a new series and the search results are still loading
+- **sonarr**: Pass the root folder ID alongside all DeleteRootFolder events when publishing to the networking channel
+- **sonarr**: Pass the indexer ID alongside all DeleteIndexer events when publishing to the networking channel
+- **sonarr**: Pass the episode file ID alongside all DeleteEpisodeFile events when publishing to the networking channel
+- **sonarr**: Pass the download ID alongside all DeleteDownload events published to the networking channel
+- **sonarr**: Pass the blocklist item ID alongside the DeleteBlocklistItem event when publishing to the networking channel
+- **sonarr**: Construct and pass the add series body alongside AddSeries events when publishing to the networking channel
+- **sonarr**: Construct and pass the AddRootFolderBody alongside all AddRootFolder events when publishing to the networking channel
+- **radarr**: Pass the movie ID alongside all UpdateAndScan events published to the networking channel
+- **radarr**: Provide the movie ID alongside all TriggerAutomaticMovieSearch events when publishing to the networking channel
+- **radarr**: Pass in the indexer id with all TestIndexer events when publishing to the networking channel
+- **radarr**: Pass in the task name alongside the StartTask event when publishing to the networking channel
+- **radarr**: Pass in the search query for the SearchNewMovie event when publishing to the networking channel
+- **radarr**: Pass in the movie ID alongside the GetReleases event when publishing to the networking channel
+- **radarr**: Pass in the movie ID alongside the GetMovieHistory event when publishing to the networking channel
+- **radarr**: Pass the movie ID in alongside the GetMovieDetaisl event when publishing to the networking channel
+- **radarr**: Provide the movie id alongside the GetMovieCredits event when publishing to the networking channel
+- **radarr**: Pass the number of log events to fetch in with the GetLogs event when publishing to the networking channel
+- **radarr**: Construct and pass the edit movie parameters alongside the EditMovie event when publishing to the networking channel
+- **radarr**: Construct and pass params when publishing the EditIndexer event to the networking channel
+- **radarr**: Construct and pass edit collection parameters alongside the EditCollection event when publishing to the networking channel
+- **radarr**: Build and pass the edit indexer settings body with the EditAllIndexerSettings event when publishing to the networking channel
+- **radarr**: Send the parameters alongside the DownloadRelease event when publishing to the networking channel
+- **radarr**: Pass the root folder ID in with the DeleteRootFolder event when publishing to the networking channel
+- Pass the delete movie params in with the DeleteMovie event when publishing to the networking channel
+- Pass the indexer ID in with the DeleteIndexer event when sending to the networking channel
+- Pass the download ID directly in the DeleteDownload event when publishing into the networking channel
+- Blocklist Item ID passed in the DeleteBlocklistItem event when sent to the networking channel
+- AddRootFolderBody now constructed prior to AddRootFolder event being sent down the network channel
+- Cancel all requests when switching Servarr tabs to both improve performance and fix issue #15
+- **add_movie_handler_tests**: Added in a forgotten test for the build_add_movie_body function
+- Missing tagged version of docker builds in release flow
+- AddMovie Radarr event is now populated in the dispatch thread before being sent to the network thread
+- dynamically load servarrs in UI based on what configs are provided
+
+## v0.4.1 (2024-12-14)
+
+### Feat
+
+- **docs**: Updated the README with new screeshots for the Sonarr release
+- **handler**: Support for toggling the monitoring status of a specified episode in the Sonarr UI
+- **handlers**: Support for toggling the monitoring status of a season in the Sonarr UI
+- **keybindings**: Added a new keybinding for toggling the monitoring of a highlighted table item
+- **cli**: Support for toggling monitoring on a specific episode in Sonarr
+- **network**: Support for toggling the monitoring status of an episode in Sonarr
+- **cli**: Support for toggling monitoring for a specific season in Sonarr
+- **network**: Support for toggling monitoring/unmonitoring a season
+- **handlers**: Support for the episode details popup
+- **ui**: Support for the episode details UI
+- **handler**: Full handler support for the Season details UI in Sonarr
+- **ui**: Sonarr support for viewing season details
+- **cli**: Sonarr support for fetching a list of all episode files for a given series ID
+- **app**: Dispatch support for Season Details to fetch both the current downloads as well as the episode files to match qualities to them
+- **network**: Support for fetching all episode files for a given series
+- **app**: Model and modal support for the season and episode details popups
+- **cli**: Sonarr support for fetching season history events
+- **network**: Sonarr support for fetching season history
+- **ui**: Sonarr support for the series details popup
+- **ui**: Sonarr support for editing a series from within the series details popup
+- **ui**: Sonarr Series details UI is now available
+- **ui**: Full Sonarr system tab support
+- **handler**: System handler support for Sonarr
+- **ui**: Full Sonarr support for the indexer tab
+- **ui**: Support for modifying the indexer priority in Radarr
+- **handler**: Full indexer tab handler support
+- **ui**: Root folder tab support
+- **handlers**: Support for root folder actions
+- **ui**: History tab support
+- **handler**: History tab support
+- **ui**: Blocklist UI support
+- **handler**: Wired in the blocklist handler to the main handlers
+- **handler**: Blocklist handler support
+- **ui**: Downloads tab support
+- **handler**: Download tab support
+- **ui**: Edit series support
+- **handler**: Edit series support
+- **ui**: Add series support Sonarr
+- **handler**: Add series support for Sonarr
+- **ui**: Delete a series
+- **handler**: Support for deleting a series in Sonarr
+- **ui**: Support for the Series table
+- **handlers**: Sonarr key support for the Series table
+- **models**: Added the necessary contextual help and tabs for the Sonarr UI
+- **ui**: Initial UI support for switching to Sonarr tabs
+- **app**: Dispatch support for all relevant Sonarr blocks
+
+### Fix
+
+- **blocklist_handler**: Fixed a breaking change between Sonarr v3 and v4
+- **style**: Addressed linter complaints on formatting
+- Implemented a handful of fixes that are breaking changes between Sonarr v3 and v4
+- **handler_tests**: Fixed all delegation tests to have initial conditions set properly
+- **ui**: Fixed a bug that requires a minimum height for all popups so all error messages and other simple popups appear
+- **handler**: Fixed a bug in the history handler that wouldn't reset the filter or search if a user hit 'esc' on the History tab
+- **ui**: Fix the System Details Tasks popup to be navigable in both Sonarr and Radarr
+- **ui**: Fixed a potential rare bug in the UI where the application would panic if the height of the downloads window is 0.
+
+### Refactor
+
+- **network**: Changed the toggle episode monitoring handler to simply return empty since the response is always empty from Sonarr
+- **ui**: Tweaked some of the color schemes in the series table
+- Fixed a couple of typos in some test function names
+- **handlers**: Refactored the handlers to all use the handle_table_events macro when appropriate and created tests for the macro so tests don't have to be duplicated across each handler
+- **ui**: Simplified the popup delegation so all future UI is easier to implement
+- **indexers_handler**: Use the new handle_table_events macro
+- **root_folders_handler**: Use the new handle_table_events macro
+- **blocklist_handler**: Use the new handle_table_events macro
+- **downloads_handler**: Use the new handle_table_events macro
+- **collection_details_handler**: use the new handle_table_events macro
+- **collections_handler**: Use the new handle_table_events macro
+- **movie_details_handler**: Use the new handle_table_events macro
+- **library_handler**: Radarr use the new handle_table_events macro
+- **indexers_handler**: Use the new handle_table_events macro
+- **indexers_handler**: Use the new handle_table_events macro
+- **root_folder_handler**: Use the new handle_table_events macro
+- **history_handler**: Use the new handle_table_event macro
+- **blocklist_handler**: Use the new handle_table_events macro
+- **downloads_handler**: Use the new handle_table_events macro
+- **series_details_handler**: Use the new handle_table_events macro
+- **handler**: Created a macro to handle all table key events to reduce code duplication and make future implementations faster; Only refactored the Sonarr library to use it thus far
+- **ui**: all table search and filter functionality is now available directly through the ManagarrTable widget to make life easier moving forward
+- **keys**: Created a auto search key instead of reusing the existing search key to make things easier
+- **BlockSelectionState**: Refactored so selection of blocks in 2x2 grids is more intuitive and added left() and right() methods to aid this effort.
+
+### Perf
+
+- Improved performance by optimizing API calls to only refresh when the tick prompts a refresh. All UI is now significantly faster
+
+## v0.3.7 (2024-11-26)
+
+### Fix
+
+- **ci**: Forgot to also pull in the most recent changes [skip ci]
+
+## v0.3.6 (2024-11-26)
+
+### Fix
+
+- **ci**: Ensure the Release Crate job fetches the most recent commit before publishing the crate [skip ci]
+
+## v0.3.4 (2024-11-26)
+
+## v0.3.3 (2024-11-26)
+
+### Fix
+
+- **ci**: Properly prefix version tags with 'v' [skip ci]
+- **ci**: Bump the version in the Cargo.lock file and commit it as well when releasing [skip ci]
+
+## v0.3.2 (2024-11-26)
+
+### Fix
+
+- **ci**: Updated the Cargo.lock file [skip ci]
+- **ci**: Use a different GitHub action to release the crate to Crates.io [skip ci]
+- **ci**: Don't manually push the tags and let Commitizen do it [skip ci]
+
+## v0.3.1 (2024-11-26)
+
+### Fix
+
+- **ci**: Don't manually push the tags and let Commitizen do it [skip ci]
+- **ci**: Fixed a typo in the version creation on GitHub [skip ci]
+
+## v0.3.0 (2024-11-26)
+
+### Feat
+
+- **cli**: Support for editing a sonarr series
+- **models**: Added the ActiveSonarrBlocks for editing a series
+- **network**: Support for editing a series in Sonarr
+- **models**: Created the EditSeriesModal
+- **cli**: Support for editing Sonarr indexers
+- **network**: Support for editing a sonarr indexer
+- **cli**: Support for deleting an episode file from disk
+- **network**: Support for deleting an episode file from disk in Sonarr
+- **cli**: Support for editing all indexer settings in Sonarr
+- **models**: Added the ActiveSonarrBlocks for editing all indexer settings
+- **network**: Support for editing all sonarr indexer settings
+- **cli**: Support for searching for new series to add to Sonarr
+- **network**: Support for searching for new series
+- **cli**: Support for adding a series to Sonarr
+- **cli**: Support for adding a series to Sonarr
+- **network**: Support for adding a new series to Sonarr
+- **cli**: Support for fetching all sonarr language profiles
+- **network**: Support for fetching all Sonarr language profiles
+- **cli**: Support for deleting a series from Sonarr
+- **network**: Support for deleting a series from Sonarr
+- **cli**: Support for downloading an episode release in Sonarr
+- **cli**: Support for downloading a season release in Sonarr
+- **cli**: Support for downloading a Series release in Sonarr
+- **network**: Support for downloading releases from Sonarr
+- **cli**: Support for refreshing Sonarr downloads
+- **network**: Support for updating Sonarr downloads
+- **cli**: Support for refreshing a specific series in Sonarr
+- **network**: Support for updating and scanning a series in Sonarr
+- **cli**: Support for refreshing all Sonarr series data
+- **network**: Support for updating all series in Sonarr
+- **cli**: Support for triggering an automatic episode search in Sonarr
+- **cli**: Support for triggering an automatic season search in Sonarr
+- **cli**: Support for triggering an automatic series search in Sonarr
+- **network**: Support for triggering an automatic episode search in Sonarr
+- **network**: Support for triggering an automatic season search in Sonarr
+- **network**: Support for triggering an automatic series search in Sonarr
+- **cli**: Support for testing all Sonarr indexers at once
+- **network**: Support for testing all Sonarr indexers at once
+- **cli**: Support for testing an individual Sonarr indexer
+- **network**: Added the ability to test an individual indexer in Sonarr
+- **cli**: Support for starting a Sonarr task
+- **network**: Support for starting a Sonarr task
+- **cli**: Support for listing Sonarr updates
+- **network**: Support for fetching Sonarr updates
+- **cli**: Support for listing all Sonarr tasks
+- **network**: Support for fetching all Sonarr tasks
+- **cli**: Support for marking a Sonarr history item as 'failed'
+- **network**: Support for marking a Sonarr history item as failed
+- **cli**: Support for listing the available disk space for all provisioned root folders in both Radarr and Sonarr
+- **network**: Support for listing disk space on a Sonarr instance
+- **cli**: Support for listing all Sonarr tags
+- **cli**: Support for adding a root folder to Sonarr
+- **cli**: CLI support for adding a tag to Sonarr
+- **network**: Support for fetching and listing all Sonarr tags
+- **network**: Support for deleting tags from Sonarr
+- **network**: Support for adding tags to Sonarr
+- **network**: Support for adding a root folder to Sonarr
+- **cli**: Support for deleting a root folder from Sonarr
+- **network**: Support for deleting a Sonarr root folder
+- **cli**: Support for fetching all Sonarr root folders
+- **network**: Support for fetching all Sonarr root folders
+- **cli**: Support for deleting a Sonarr indexer
+- **network**: Support for deleting an indexer from Sonarr
+- **cli**: Support for deleting a download from Sonarr
+- **network**: Support for deleting a download from Sonarr
+- **cli**: Support for fetching episode history events from Sonarr
+- **network**: Support for fetching episode history
+- **cli**: Added a spinner to the CLI for long running commands like fetching releases
+- **cli**: Support for fetching history for a given series ID
+- **network**: Support for fetching Sonarr series history for a given series ID
+- **cli**: Support for fetching all Sonarr history events
+- **network**: Support to fetch all Sonarr history events
+- **models**: Added an additional History tab to the mocked tabs for viewing all Sonarr history at once
+- **models**: Stubbed out the necessary ActiveSonarrBlocks for the UI mockup
+- **cli**: Added support for manually searching for episode releases in Sonarr
+- **network**: Added support for fetching episode releases in Sonarr
+- **cli**: Added CLI support for fetching series details in Sonarr
+- **network**: Added support for fetching series details for a given series ID in Sonarr
+- **cli**: Added support for manually searching for season releases for Sonarr
+- **network**: Added support for fetching season releases for Sonarr
+- **cli**: Added support for listing Sonarr queued events
+- **network**: Added support for fetching Sonarr queued events
+- **cli**: Added CLI support for fetching all indexer settings for Sonarr
+- **network**: Added netwwork support for fetching all indexer settings for Sonarr
+- **cli**: Added Sonarr support for fetching host and security configs
+- **network**: Added network support for fetching host and security configs from Sonarr
+- **cli**: Added CLI support for listing Sonarr indexers
+- **network**: Added the GetIndexers network call for Sonarr
+- **cli**: Added sonarr support for listing downloads, listing quality profiles, and fetching detailed information about an episode
+- **network**: Added get quality profiles and get episode details events for Sonarr
+- **cli**: Sonarr CLI support for fetching all episodes for a given series
+- **sonarr_network**: Added support for fetching episodes for a specified series to the network events
+- **models**: Added the Episode model to Sonarr models
+- **models**: Created the StatefulTree struct for displaying seasons and episodes (and any other structured data) for the UI.
+- **sonarr**: Added CLI support for listing Sonarr logs
+- **sonarr**: Added the ability to fetch Sonarr logs
+- **sonarr**: Added blocklist commands (List, Clear, Delete)
+- Added initial Sonarr CLI support and the initial network handler setup for the TUI
+- Added a new command to the main managarr CLI: tail-logs, to enable users to tail the Managarr logs without needing to know where the log file itself is located
+
+### Fix
+
+- Reverted to old version to fix release [skip ci]
+- **minimal-versions**: Addressed concerns with the minimal-versions CI checks
+- **lint**: Addressed linter complaints
+- **cli**: Corrected some copy/paste typos
+- **network**: Force sonarr to save edits to indexers
+- **network**: Made the overview field nullable in the Sonarr series model
+- **network**: Added filtering for full seasons specifically in the UI when performing a manual full season search and added a message to the CLI that noes to only try to download a full season if that release includes 'fullSeason: true'
+- **network**: Not all Sonarr tasks return the lastDuration field and was causing a crash
+- **network**: Fixed an issue with dynamic typing in responses from Sonarr for history items
+- **config**: The CLI panics if the servarr you specify has no config defined
+- Imported a missing macro in the panic hook
+
+### Refactor
+
+- **cli**: the trigger-automatic-search commands now all have their own dedicated subcommand to keep things cleaner. Now they look like 'trigger-automatic-search episode/series/season' and their corresponding flags
+- **cli**: Added an additional delegation test to ensure manual-search commands are delegated to the manual-search command handler
+- **cli**: Moved the manual-season-search and manual-episode-search commands into their own dedicated handler so the commands can now be manual-search episode or manual-search season
+
+## v0.2.2 (2024-11-06)
+
+### Fix
+
+- **handler**: Fixed a bug in the movie details handler that would allow key events to be processed before the data was finished loading
+- **ui**: Fixed a bug that would freeze all user input while background network requests were running
+- **radarr_ui**: Fixed a race condition bug in the movie details UI that would panic if the user changes tabs too quickly
+
+### Perf
+
+- **network**: Improved performance and reactiveness of the UI by speeding up network requests and clearing the channel whenever a request is cancelled/the UI is routing
+
+## v0.2.1 (2024-11-06)
+
+## [0.2.1](https://github.com/Dark-Alex-17/managarr/compare/v0.2.0...v0.2.1) - 2024-11-06
+
+### Other
+
+- Removed the need for use_ssl to indicate SSL usage; instead just use the ssl_cert_path
+- Applied bug fix to the downloads tab as well as the context [skip ci]
+- Updated the README to not include the GitHub downloads badge since all binary releases are on crates.io [skip ci]
+- Set all releases as manually triggered instead of automatic [skip ci]
+- Updated dockerfile to no longer use the --disable-terminal-size-checks flag [skip ci]
+
+## [0.1.5](https://github.com/Dark-Alex-17/managarr/compare/v0.1.4...v0.1.5) - 2024-11-03
+
+### Other
+
+- Added HTTPS support for all Servarrs
+
+## [0.1.4](https://github.com/Dark-Alex-17/managarr/compare/v0.1.3...v0.1.4) - 2024-11-01
+
+### Other
+
+- Added the ability to fetch host configs and security configs to the CLI
+- Updated README to be more clear about what features are supported [skip ci]
 
 ## [0.1.2](https://github.com/Dark-Alex-17/managarr/compare/v0.1.1...v0.1.2) - 2024-10-30
 

CONTRIBUTING.md

@@ -1,6 +1,24 @@
 # Contributing
 Contributors are very welcome! **No contribution is too small and all contributions are valued.**
 
+## License and Attribution
+
+#### _If you plan on contributing to the base project, no attribution is needed!_ Feel free to proceed to the [next steps](CONTRIBUTING.md#Rust).
+
+Otherwise, below are key points to understand from the [Managarr License, Version 1.0](LICENSE):
+1. **Non-Commercial Use**:
+   - Managarr is licensed solely for non-commercial purposes. Any commercial use of Managarr (e.g., selling or offering as a paid service) requires separate permission.
+
+2. **Attribution when Forking and Redistributing Without Contributing back to Main Project**:
+   - **If you fork the project and distribute it separately** (e.g., publish or _publicly_ host it independently from the original project), you are required to provide attribution. 
+   - You may credit the original author by using any of the following phrasing:
+     - "Thanks to Alexander J. Clarke (Dark-Alex-17) for creating the original Managarr project!"
+     - "Forked from the Managarr project, created by Alexander J. Clarke (Dark-Alex-17)"
+     - "This software is based on the original Managarr project by Alexander J. Clarke (Dark-Alex-17)"
+     - "Inspired by Alexander J. Clarke (Dark-Alex-17)'s Managarr project"
+   - If changes are made to the base Managarr project, please note those modifications and provide the new attribution accordingly.
+
+## Rust
 You'll need to have the stable Rust toolchain installed in order to develop Managarr.
 
 The Rust toolchain (stable) can be installed via rustup using the following command:
@@ -11,15 +29,74 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
 This will install `rustup`, `rustc` and `cargo`. For more information, refer to the [official Rust installation documentation](https://www.rust-lang.org/tools/install). 
 
+## Commitizen
+[Commitizen](https://github.com/commitizen-tools/commitizen?tab=readme-ov-file) is a nifty tool that helps us write better commit messages. It ensures that our 
+commits have a consistent style and makes it easier to generate CHANGELOGS. Additionally, 
+Commitizen is used to run pre-commit checks to enforce style constraints. 
+
+To install `commitizen` and the `pre-commit` prerequisite, run the following command:
+
+```shell
+python3 -m pip install commitizen pre-commit
+```
+
+### Commitizen Quick Guide
+To see an example commit to get an idea for the Commitizen style, run:
+
+```shell
+cz example
+```
+
+To see the allowed types of commits and their descriptions, run:
+
+```shell
+cz info
+```
+
+If you'd like to create a commit using Commitizen with an interactive prompt to help you get
+comfortable with the style, use:
+
+```shell
+cz commit
+```
+
 ## Setup workspace
 
 1. Clone this repo
-2. Run `cargo test` to setup hooks
+2. Run `cargo test` to set up hooks
 3. Make changes
-4. Run the application using `make run` or `cargo run`
+4. Run the application using `just run` or `just run`
+   - Install `just` (`cargo install just`) if you haven't already to use the [justfile](./justfile) in this project.
 5. Commit changes. This will trigger pre-commit hooks that will run format, test and lint. If there are errors or warnings from Clippy, please fix them.
 6. Push your code to a new branch named after the feature/bug/etc. you're adding. This will trigger pre-push hooks that will run lint and test.
 7. Create a PR
 
+### CI/CD Testing with Act
+If you also are planning on testing out your changes before pushing them with [Act](https://github.com/nektos/act), you will need to set up `act`,
+`docker`, and configure your local system to run different architectures:
+
+1. Install `docker` by following the instructions on the [official Docker installation page](https://docs.docker.com/get-docker/).
+2. Install `act` by following the instructions on the [official Act installation page](https://nektosact.com/installation/index.html).
+3. Install `binfmt` on your system once so that `act` can run the correct architecture for the CI/CD workflows. 
+   You can do this by running:
+   ```shell
+   sudo docker run --rm --privileged tonistiigi/binfmt --install all
+   ```
+   
+Then, you can run workflows locally without having to commit and see if the GitHub action passes or fails. 
+
+**For example**: To test the [release.yml](.github/workflows/release.yml) workflow locally, you can run:
+
+```shell
+act -W .github/workflows/release.yml --input_type bump=minor
+```
+
+## Authorship Policy
+
+All code in this repository is written and reviewed by humans. AI-generated code (e.g., Copilot, ChatGPT,
+Claude, etc.) is not permitted unless explicitly disclosed and approved.
+
+Submissions must certify that the contributor understands and can maintain the code they submit.
+
 ## Questions? Reach out to me!
 If you encounter any questions while developing Managarr, please don't hesitate to reach out to me at alex.j.tusa@gmail.com. I'm happy to help contributors, new and experienced in any way I can!

Cargo.toml

@@ -1,60 +1,86 @@
 [package]
 name = "managarr"
-version = "0.1.2"
+version = "0.7.1"
 authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
 description = "A TUI and CLI to manage your Servarrs"
-keywords = ["managarr", "tui-rs", "dashboard", "servarr", "tui"]
+keywords = ["managarr", "ratatui", "dashboard", "servarr", "tui"]
 documentation = "https://github.com/Dark-Alex-17/managarr"
 repository = "https://github.com/Dark-Alex-17/managarr"
 homepage = "https://github.com/Dark-Alex-17/managarr"
 readme = "README.md"
-edition = "2021"
+edition = "2024"
 license = "MIT"
-rust-version = "1.82.0"
+rust-version = "1.89.0"
 exclude = [".github", "CONTRIBUTING.md", "*.log", "tags"]
 
+[workspace]
+members = [
+  "proc_macros/enum_display_style_derive",
+  "proc_macros/validate_theme_derive",
+]
+
 [dependencies]
-anyhow = "1.0.68"
+anyhow = "1.0.100"
-backtrace = "0.3.67"
+backtrace = "0.3.76"
 bimap = { version = "0.6.3", features = ["serde"] }
-chrono = { version = "0.4.38", features = ["serde"] }
+chrono = { version = "0.4.43", features = ["serde"] }
-confy = { version = "0.6.0", default-features = false, features = [
+confy = { version = "2.0.0", default-features = false, features = [
   "yaml_conf",
 ] }
-crossterm = "0.27.0"
+crossterm = "0.28.1"
 derivative = "2.2.0"
-human-panic = "1.1.3"
+human-panic = "2.0.6"
-indoc = "2.0.0"
+indoc = "2.0.7"
-log = "0.4.17"
+log = "0.4.29"
-log4rs = { version = "1.2.0", features = ["file_appender"] }
+log4rs = { version = "1.4.0", features = ["file_appender"] }
-regex = "1.11.1"
+regex = "1.12.2"
-reqwest = { version = "0.11.14", features = ["json"] }
+reqwest = { version = "0.12.28", features = ["json"] }
-serde_yaml = "0.9.16"
+serde_yaml = "0.9.34"
-serde_json = "1.0.91"
+serde_json = "1.0.149"
-serde = { version = "1.0.214", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-tokio = { version = "1.36.0", features = ["full"] }
+tokio = { version = "1.49.0", features = ["full"] }
-tokio-util = "0.7.8"
+tokio-util = "0.7.18"
-ratatui = { version = "0.28.0", features = ["all-widgets"] }
+ratatui = { version = "0.30.0", features = [
-urlencoding = "2.1.2"
+  "all-widgets",
-clap = { version = "4.5.20", features = ["derive", "cargo"] }
+  "unstable-widget-ref",
-clap_complete = "4.5.33"
+] }
-itertools = "0.13.0"
+urlencoding = "2.1.3"
-ctrlc = "3.4.5"
+clap = { version = "4.5.56", features = [
-colored = "2.1.0"
+  "derive",
-async-trait = "0.1.83"
+  "cargo",
+  "env",
+  "wrap_help",
+] }
+clap_complete = "4.5.65"
+itertools = "0.14.0"
+ctrlc = "3.5.1"
+colored = "3.1.1"
+async-trait = "0.1.89"
 dirs-next = "2.0.0"
+managarr-tree-widget = "0.25.0"
+indicatif = "0.17.11"
+derive_setters = "0.1.9"
+deunicode = "1.6.2"
+openssl = { version = "0.10.75", features = ["vendored"] }
+veil = "0.2.0"
+validate_theme_derive = "0.1.0"
+enum_display_style_derive = "0.1.0"
 
 [dev-dependencies]
-assert_cmd = "2.0.16"
+assert_cmd = "2.1.2"
-mockall = "0.13.0"
+mockall = "0.13.1"
-mockito = "1.0.0"
+mockito = "1.7.1"
-pretty_assertions = "1.3.0"
+pretty_assertions = "1.4.1"
-rstest = "0.18.2"
+proptest = "1.9.0"
+rstest = "0.25.0"
+serial_test = "3.3.1"
+assertables = "9.8.4"
+insta = "1.46.1"
 
 [dev-dependencies.cargo-husky]
-version = "1"
+version = "1.5.0"
 default-features = false
 features = ["user-hooks"]
 
@@ -65,4 +91,6 @@ name = "managarr"
 
 [profile.release]
 lto = true
-codegen-units = 1
+codegen-units = 3
+opt-level = "s"
+strip = true

Dockerfile

@@ -1,4 +1,4 @@
-FROM clux/muslrust:stable AS builder
+FROM rust:1.89 AS builder
 WORKDIR /usr/src
 
 # Download and compile Rust dependencies in an empty project and cache as a separate Docker layer
@@ -6,17 +6,18 @@ RUN USER=root cargo new --bin managarr-temp
 
 WORKDIR /usr/src/managarr-temp
 COPY Cargo.* .
-RUN cargo build --release --target x86_64-unknown-linux-musl
+COPY proc_macros ./proc_macros
+RUN cargo build --release
 # remove src from empty project
 RUN rm -r src
 COPY src ./src
 # remove previous deps
-RUN rm ./target/x86_64-unknown-linux-musl/release/deps/managarr*
+RUN rm ./target/release/deps/managarr*
 
 RUN --mount=type=cache,target=/volume/target \
     --mount=type=cache,target=/root/.cargo/registry \
-    cargo build --release --target x86_64-unknown-linux-musl --bin managarr
+    cargo build --release --bin managarr
-RUN mv target/x86_64-unknown-linux-musl/release/managarr .
+RUN mv target/release/managarr .
 
 FROM debian:stable-slim
 

LICENSE

@@ -1,16 +1,53 @@
-MIT License
+Managarr License
+Version 1.0, 2025
 
-Copyright (c) 2023 Alexander J. Clarke
+Copyright (c) 2025 Alexander J. Clarke (Dark-Alex-17)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy 
-of this software and associated documentation files (the "Software"), to deal
+of this software and associated documentation files (the "Software"), to use, 
-in the Software without restriction, including without limitation the rights
+copy, modify, merge, publish, and distribute the Software solely for 
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+non-commercial purposes, subject to the following conditions:
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+1. Attribution:
-copies or substantial portions of the Software.
+   - The above copyright notice, this permission notice, and a prominent notice stating 
+     that the Software is part of the "Managarr" project shall be included in all copies or 
+     substantial portions of the Software **when the Software is forked and redistributed separately** from the original project.
+   - If you fork the software and **distribute it separately** without merging it back into the original base project (the Managarr repository), you must provide attribution to the original author.
+     You may use any of the following forms of attribution:
+     - "Thanks to Alexander J. Clarke (Dark-Alex-17) for creating the original Managarr project!"
+     - "Forked from the Managarr project, created by Alexander J. Clarke (Dark-Alex-17)"
+     - "This software is based on the original Managarr project by Alexander J. Clarke (Dark-Alex-17)"
+     - "Inspired by Alexander J. Clarke (Dark-Alex-17)'s Managarr project"
+   - If you modify the software, the attribution must also note that changes were made and describe those modifications, if feasible.
+
+2. Non-Commercial Use Only:
+   The use of this Software for commercial purposes, including but not limited 
+   to sale, licensing, or use in any product or service for monetary 
+   compensation, is strictly prohibited without prior written permission from 
+   Alexander J. Clarke (Dark-Alex-17).
+
+   For avoidance of doubt:
+   - **Allowed:** Private use, educational purposes, research, or any usage 
+     that does not directly generate revenue.
+   - **Prohibited:** Selling, sublicensing, or incorporating the Software into 
+     commercial products or services.
+
+3. Modifications and Derivatives:
+   - Any modifications or derivative works based on this Software must clearly 
+     document all changes made and prominently credit the original "Managarr" 
+     project as described in section 1.
+   - Derivative works must retain this license, the original copyright notice, 
+     and all terms and conditions described herein. This applies to the entire 
+     derivative work, even if combined with other software.
+
+4. Warranty Disclaimer:
+   This Software is provided "as is," without warranty of any kind, express 
+   or implied, including but not limited to the warranties of merchantability, 
+   fitness for a particular purpose, and noninfringement. In no event shall the 
+   authors or copyright holders be liable for any claim, damages, or other 
+   liability, whether in an action of contract, tort, or otherwise, arising 
+   from, out of, or in connection with the Software or the use or other 
+   dealings in the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

Makefile

@@ -1,47 +0,0 @@
-#!make
-VERSION  := latest
-IMG_NAME := darkalex17/managarr
-IMAGE    := ${IMG_NAME}:${VERSION}
-
-default: run
-
-.PHONY: test test-cov build run lint lint-fix fmt analyze sonar release delete-tag
-
-test:
-	@cargo test
-
-## Run all tests with coverage - `cargo install cargo-tarpaulin`
-test-cov:
-	@cargo tarpaulin
-
-build: test
-	@cargo build --release
-
-docker:
-	@DOCKER_BUILDKIT=1 docker build --rm -t ${IMAGE} .
-
-run:
-	@CARGO_INCREMENTAL=1 cargo fmt && make lint && cargo run
-
-lint:
-	@find . | grep '\.\/src\/.*\.rs$$' | xargs touch && CARGO_INCREMENTAL=0 cargo clippy --all-targets --workspace
-
-lint-fix:
-	@cargo fix
-
-fmt:
-	@cargo fmt
-
-minimal-versions:
-	@cargo +nightly update -Zdirect-minimal-versions
-
-## Analyze for unsafe usage - `cargo install cargo-geiger`
-analyze:
-	@cargo geiger
-
-release:
-	@git tag -a ${V} -m "Release ${V}" && git push origin ${V}
-
-delete-tag:
-	@git tag -d ${V} && git push --delete origin ${V}
-

README.md

@@ -1,32 +1,33 @@
 # managarr - A TUI and CLI to manage your Servarrs
 
-![check](https://github.com/Dark-Alex-17/managarr/actions/workflows/check.yml/badge.svg)
+![Check](https://github.com/Dark-Alex-17/managarr/actions/workflows/check.yml/badge.svg)
-![test](https://github.com/Dark-Alex-17/managarr/actions/workflows/test.yml/badge.svg)
+![Test](https://github.com/Dark-Alex-17/managarr/actions/workflows/test.yml/badge.svg)
-![test](https://github.com/Dark-Alex-17/managarr/actions/workflows/release.yml/badge.svg)
 ![License](https://img.shields.io/badge/license-MIT-blueviolet.svg)
 ![LOC](https://tokei.rs/b1/github/Dark-Alex-17/managarr?category=code)
 [![crates.io link](https://img.shields.io/crates/v/managarr.svg)](https://crates.io/crates/managarr)
 ![Release](https://img.shields.io/github/v/release/Dark-Alex-17/managarr?color=%23c694ff)
 [![codecov](https://codecov.io/gh/Dark-Alex-17/managarr/graph/badge.svg?token=33G179TW67)](https://codecov.io/gh/Dark-Alex-17/managarr)
-[![GitHub Downloads](https://img.shields.io/github/downloads/Dark-Alex-17/managarr/total.svg?label=GitHub%20downloads)](https://github.com/Dark-Alex-17/managarr/releases)
 ![Crate.io downloads](https://img.shields.io/crates/d/managarr?label=Crate%20downloads)
+[![GitHub Downloads](https://img.shields.io/github/downloads/Dark-Alex-17/managarr/total.svg?label=GitHub%20downloads)](https://github.com/Dark-Alex-17/managarr/releases)
+![Docker pulls](https://img.shields.io/docker/pulls/darkalex17/managarr?label=Docker%20downloads)
+[![Matrix](https://img.shields.io/matrix/managarr-room%3Amatrix.org?logo=matrix&server_fqdn=matrix.org&fetchMode=guest&style=social&label=Managarr%20Matrix%20Space&link=https%3A%2F%2Fmatrix.to%2F%23%2F%23managarr%3Amatrix.org)](https://matrix.to/#/#managarr:matrix.org)
 
 Managarr is a TUI and CLI to help you manage your HTPC (Home Theater PC). Built with 🤎 in Rust!
 
-![library](screenshots/library.png)
+![library](screenshots/lidarr/lidarr_library.png)
 
 ## What Servarrs are supported?
 
-- ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
+- [x] ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
-- ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
+- [x] ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
-- ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
+- [x] ![lidarr_logo](logos/lidarr.png) [Lidarr](https://wiki.servarr.com/en/lidarr)
-- ![lidarr_logo](logos/lidarr.png) [Lidarr](https://wiki.servarr.com/en/lidarr)
+- [ ] ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
-- ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
+- [ ] ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
-- ![whisparr_logo](logos/whisparr.png) [Whisparr](https://wiki.servarr.com/whisparr)
+- [ ] ![whisparr_logo](logos/whisparr.png) [Whisparr](https://wiki.servarr.com/whisparr)
-- ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
+- [ ] ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
-- ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)
+- [ ] ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)
 
-## Try Before You Buy
+## Try Out the Demo
 To try out Managarr before linking it to your HTPC, you can use the purpose built [managarr-demo](https://github.com/Dark-Alex-17/managarr-demo) repository.
 Simply run the following command to start a demo:
 
@@ -34,7 +35,10 @@ Simply run the following command to start a demo:
 curl https://raw.githubusercontent.com/Dark-Alex-17/managarr-demo/main/managarr-demo.sh > /tmp/managarr-demo.sh && bash /tmp/managarr-demo.sh
 ```
 
+Alternatively, you can try out the demo container without downloading anything by visiting the [Managarr Demo site](https://managarr-demo.alexjclarke.com).
+
 ## Installation
+
 ### Cargo
 If you have Cargo installed, then you can install Managarr from Crates.io:
 
@@ -48,42 +52,159 @@ cargo install --locked managarr
 ### Docker
 Run Managarr as a docker container by mounting your `config.yml` file to `/root/.config/managarr/config.yml`. For example:
 ```shell
-docker run --rm -it -v ~/.config/managarr:/root/.config/managarr darkalex17/managarr
+docker run --rm -it -v /home/aclarke/.config/managarr/config.yml:/root/.config/managarr/config.yml darkalex17/managarr:latest
 ```
 
-You can also clone this repo and run `make docker` to build a docker image locally and run it using the above command.
+You can also clone this repo and run `just build-docker` to build a docker image locally and run it using the above command.
+
+Please note that you will need to create and populate your configuration file first before starting the container. Otherwise, the container will fail to start.
+
+**Note:** If you run into errors using relative file paths when mounting the volume with the configuration file, try using an absolute path.
+
+### Homebrew (Mac and Linux)
+To install Managarr from Homebrew, install the Managarr tap. Then you'll be able to install Managarr:
+
+```shell
+brew tap Dark-Alex-17/managarr
+brew install managarr
+
+# If you need to be more specific, use the following:
+brew install Dark-Alex-17/managarr/managarr
+```
+
+To upgrade to a newer version of Managarr:
+```shell
+brew upgrade managarr
+```
+
+### Nix (Externally Maintained)
+To install Managarr on NixOS, you can use the following command:
+
+```shell
+nix-env --install managarr
+
+# Alternatively, for non-NixOS users, you can spawn a temporary shell with Managarr available like so:
+nix-shell -p managarr
+```
+
+### Chocolatey (Windows)
+The Managarr Chocolatey package is located [here](https://community.chocolatey.org/packages/managarr). Please note that validation
+of Chocolatey packages take quite some time, and thus the package may not be available immediately after a new release.
+
+```powershell
+choco install managarr
+
+# Some newer releases may require a version number, so you can specify it like so:
+choco install managarr --version=0.7.0
+```
+
+To upgrade to the latest and greatest version of Managarr:
+```powershell
+choco upgrade managarr
+
+# To upgrade to a specific version:
+choco upgrade managarr --version=0.7.0
+```
+
+### Manual
+Binaries are available on the [releases](https://github.com/Dark-Alex-17/managarr/releases) page for the following platforms:
+
+| Platform       | Architecture(s)            |
+|----------------|----------------------------|
+| macOS          | x86_64, arm64              |
+| Linux GNU/MUSL | x86_64,armv6,armv7,aarch64 |
+| Windows        | x86_64,aarch64             |
+
+#### Windows Instructions
+To use a binary from the releases page on Windows, do the following:
+
+1. Download the latest [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+2. Use 7-Zip or TarTool to unpack the Tar file.
+3. Run the executable `managarr.exe`!
+
+#### Linux/MacOS Instructions
+To use a binary from the releases page on Linux/MacOS, do the following:
+
+1. Download the latest [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+2. `cd` to the directory where you downloaded the binary.
+3. Extract the binary with `tar -C /usr/local/bin -xzf managarr-<arch>.tar.gz` (Note: This may require `sudo`)
+4. Now you can run `managarr`!
 
 ## Features
+Key:
+
+| Symbol | Status    |
+|--------|-----------|
+| ✅      | Supported |
+| ❌      | Missing   |
+| 🕒     | Planned   |
+| 🚫     | Won't Add |
 
 ### Radarr
 
-- [x] View your library, downloads, collections, and blocklist
+| TUI | CLI | Feature                                                                                                        |
-- [x] View details of a specific movie including description, history, downloaded file info, or the credits
+|-----|-----|----------------------------------------------------------------------------------------------------------------|
-- [x] View details of any collection and the movies in them
+| ✅   | ✅   | View your library, downloads, collections, and blocklist                                                       |
-- [x] Search your library or collections
+| ✅   | ✅   | View details of a specific movie including description, history, downloaded file info, or the credits          |
-- [x] Add movies to your library
+| ✅   | ✅   | View details of any collection and the movies in them                                                          |
-- [x] Delete movies, downloads, and indexers
+| 🚫  | ✅   | View your host and security configs from the CLI to programmatically fetch the API token, among other settings |
-- [x] Trigger automatic searches for movies
+| ✅   | ✅   | Search your library or collections                                                                             |
-- [x] Trigger refresh and disk scan for movies, downloads, and collections
+| ✅   | ✅   | Add movies to your library                                                                                     |
-- [x] Manually search for movies
+| ✅   | ✅   | Delete movies, downloads, and indexers                                                                         |
-- [x] Edit your movies, collections, and indexers
+| ✅   | ✅   | Trigger automatic searches for movies                                                                          |
-- [x] Manage your tags
+| ✅   | ✅   | Trigger refresh and disk scan for movies, downloads, and collections                                           |
-- [x] Manage your root folders
+| ✅   | ✅   | Manually search for movies                                                                                     |
-- [x] Manage your blocklist
+| ✅   | ✅   | Edit your movies, collections, and indexers                                                                    |
-- [x] View and browse logs, tasks, events queues, and updates
+| ✅   | ✅   | Manage your tags                                                                                               |
-- [x] Manually trigger scheduled tasks
+| ✅   | ✅   | Manage your root folders                                                                                       |
+| ✅   | ✅   | Manage your blocklist                                                                                          |
+| ✅   | ✅   | View and browse logs, tasks, events queues, and updates                                                        |
+| ✅   | ✅   | Manually trigger scheduled tasks                                                                               |
 
 ### Sonarr
-- [ ] Support for Sonarr
+
+| TUI | CLI | Feature                                                                                                            |
+|-----|-----|--------------------------------------------------------------------------------------------------------------------|
+| ✅   | ✅   | View your library, downloads, blocklist, episodes                                                                  |
+| ✅   | ✅   | View details of a specific series, or episode including description, history, downloaded file info, or the credits |
+| 🚫  | ✅   | View your host and security configs from the CLI to programmatically fetch the API token, among other settings     |
+| ✅   | ✅   | Search your library                                                                                                |
+| ✅   | ✅   | Add series to your library                                                                                         |
+| ✅   | ✅   | Delete series, downloads, indexers, root folders, and episode files                                                |
+| ✅   | ✅   | Trigger automatic searches for series, seasons, or episodes                                                        |
+| ✅   | ✅   | Trigger refresh and disk scan for series and downloads                                                             |
+| ✅   | ✅   | Manually search for series, seasons, or episodes                                                                   |
+| ✅   | ✅   | Edit your series and indexers                                                                                      |
+| ✅   | ✅   | Manage your tags                                                                                                   |
+| ✅   | ✅   | Manage your root folders                                                                                           |
+| ✅   | ✅   | Manage your blocklist                                                                                              |
+| ✅   | ✅   | View and browse logs, tasks, events queues, and updates                                                            |
+| ✅   | ✅   | Manually trigger scheduled tasks                                                                                   |
+
+### Lidarr
+
+| TUI | CLI | Feature                                                                                                        |
+|-----|-----|----------------------------------------------------------------------------------------------------------------|
+| ✅   | ✅   | View your library, downloads, blocklist, tracks                                                                |
+| ✅   | ✅   | View details of a specific artists, albums, or tracks including description, history, downloaded file info     |
+| 🚫  | ✅   | View your host and security configs from the CLI to programmatically fetch the API token, among other settings |
+| ✅   | ✅   | Search your library                                                                                            |
+| ✅   | ✅   | Add artists to your library                                                                                    |
+| ✅   | ✅   | Delete artists, downloads, indexers, root folders, and track files                                             |
+| ✅   | ✅   | Trigger automatic searches for artists or albums                                                               |
+| ✅   | ✅   | Trigger refresh and disk scan for artists and downloads                                                        |
+| ✅   | ✅   | Manually search for  full artist discographies or albums                                                       |
+| ✅   | ✅   | Edit your artists and indexers                                                                                 |
+| ✅   | ✅   | Manage your tags                                                                                               |
+| ✅   | ✅   | Manage your root folders                                                                                       |
+| ✅   | ✅   | Manage your blocklist                                                                                          |
+| ✅   | ✅   | View and browse logs, tasks, events queues, and updates                                                        |
+| ✅   | ✅   | Manually trigger scheduled tasks                                                                               |
 
 ### Readarr
 
 - [ ] Support for Readarr
 
-### Lidarr
-
-- [ ] Support for Lidarr
-
 ### Whisparr
 
 - [ ] Support for Whisparr
@@ -100,61 +221,113 @@ You can also clone this repo and run `make docker` to build a docker image local
 
 - [ ] Support for Tautulli
 
+### Themes
+Managarr ships with a few themes out of the box. Here's a few examples:
+
+#### Default
+![default](themes/default/manual_episode_search.png)
+#### Dracula
+![dracula](themes/dracula/manual_episode_search.png)
+#### Watermelon Dark
+![watermelon-dark](themes/watermelon-dark/manual_episode_search.png)
+
+You can also create your own custom themes as well. To learn more about what themes are built-in to Managarr and how
+to create your own custom themes, check out the [Themes README](themes/README.md).
+
 ### The Managarr CLI
 Managarr can be used in one of two ways: As a TUI, or as a CLI for managing your Servarrs. 
 
-All management features available in the TUI are also available in the CLI.
+All management features available in the TUI are also available in the CLI. However, the CLI is
+equipped with additional features to allow for more advanced usage and automation.
 
-The CLI can be helpful for automating tasks or for use in scripts. For example, you can use the CLI to trigger a search for a movie, or to add a movie to your library.
+The CLI can be helpful for automating tasks or for use in scripts. For example, you can use the CLI to trigger a search for a movie, or to add a movie to your Radarr library.
 
 To see all available commands, simply run `managarr --help`:
 
 ```shell
 $ managarr --help
-managarr 0.0.36
+managarr 0.7.0
 Alex Clarke <alex.j.tusa@gmail.com>
 
 A TUI and CLI to manage your Servarrs
 
-Usage: managarr [COMMAND]
+Usage: managarr [OPTIONS] [COMMAND]
 
 Commands:
   radarr       Commands for manging your Radarr instance
+  sonarr       Commands for manging your Sonarr instance
+  lidarr       Commands for manging your Lidarr instance
   completions  Generate shell completions for the Managarr CLI
+  tail-logs    Tail Managarr logs
+  config-path  Print the full path to the default configuration file.
+               This file can be changed to another location using the '--config-file' flag
   help         Print this message or the help of the given subcommand(s)
 
 Options:
   -h, --help     Print help
   -V, --version  Print version
+
+Global Options:
+      --disable-spinner              Disable the spinner (can sometimes make parsing output
+                                     challenging) [env: MANAGARR_DISABLE_SPINNER=]
+      --config-file <CONFIG_FILE>    The Managarr configuration file to use; defaults to the
+                                     path shown by 'managarr config-path' [env:
+                                     MANAGARR_CONFIG_FILE=]
+      --themes-file <THEMES_FILE>    The Managarr themes file to use [env:
+                                     MANAGARR_THEMES_FILE=]
+      --theme <THEME>                The name of the Managarr theme to use [env:
+                                     MANAGARR_THEME=]
+      --servarr-name <SERVARR_NAME>  For multi-instance configurations, you need to specify
+                                     the name of the instance configuration that you want to
+                                     use.
+                                     
+                                     This is useful when you have multiple instances of the
+                                     same Servarr defined in your config file.
+                                     By default, if left empty, the first configured Servarr
+                                     instance listed in the config file will be used.
 ```
 
-All subcommands also have detailed help menus to show you how to use them. For example, to see all available commands for Radarr, you would run:
+All subcommands also have detailed help menus to show you how to use them. For example, to see all available commands for Sonarr, you would run:
 
 ```shell
-$ managarr radarr --help
+$ managarr sonarr --help
-Commands for manging your Radarr instance
+Commands for manging your Sonarr instance
 
-Usage: managarr radarr <COMMAND>
+Usage: managarr sonarr [OPTIONS] <COMMAND>
 
 Commands:
-  add                       Commands to add or create new resources within your Radarr instance
+  add                          Commands to add or create new resources within your Sonarr instance
-  delete                    Commands to delete resources from your Radarr instance
+  delete                       Commands to delete resources from your Sonarr instance
-  edit                      Commands to edit resources in your Radarr instance
+  edit                         Commands to edit resources in your Sonarr instance
-  get                       Commands to fetch details of the resources in your Radarr instance
+  get                          Commands to fetch details of the resources in your Sonarr instance
-  list                      Commands to list attributes from your Radarr instance
+  download                     Commands to download releases in your Sonarr instance
-  refresh                   Commands to refresh the data in your Radarr instance
+  list                         Commands to list attributes from your Sonarr instance
-  clear-blocklist           Clear the blocklist
+  refresh                      Commands to refresh the data in your Sonarr instance
-  download-release          Manually download the given release for the specified movie ID
+  manual-search                Commands to manually search for releases
-  manual-search             Trigger a manual search of releases for the movie with the given ID
+  trigger-automatic-search     Commands to trigger automatic searches for releases of different resources in your Sonarr instance
-  search-new-movie          Search for a new film to add to Radarr
+  clear-blocklist              Clear the blocklist
-  start-task                Start the specified Radarr task
+  mark-history-item-as-failed  Mark the Sonarr history item with the given ID as 'failed'
-  test-indexer              Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'
+  search-new-series            Search for a new series to add to Sonarr
-  test-all-indexers         Test all indexers
+  start-task                   Start the specified Sonarr task
-  trigger-automatic-search  Trigger an automatic search for the movie with the specified ID
+  test-indexer                 Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'
-  help                      Print this message or the help of the given subcommand(s)
+  test-all-indexers            Test all Sonarr indexers
+  toggle-episode-monitoring    Toggle monitoring for the specified episode
+  toggle-season-monitoring     Toggle monitoring for the specified season that corresponds to the specified series ID
+  toggle-series-monitoring     Toggle monitoring for the specified series corresponding to the given series ID
+  help                         Print this message or the help of the given subcommand(s)
 
 Options:
   -h, --help  Print help
+
+Global Options:
+      --disable-spinner              Disable the spinner (can sometimes make parsing output challenging) [env: MANAGARR_DISABLE_SPINNER=]
+      --config-file <CONFIG_FILE>    The Managarr configuration file to use [env: MANAGARR_CONFIG_FILE=]
+      --themes-file <THEMES_FILE>    The Managarr themes file to use [env: MANAGARR_THEMES_FILE=]
+      --theme <THEME>                The name of the Managarr theme to use [env: MANAGARR_THEME=]
+      --servarr-name <SERVARR_NAME>  For multi-instance configurations, you need to specify the name of the instance configuration that you want to use.
+                                     
+                                     This is useful when you have multiple instances of the same Servarr defined in your config file.
+                                     By default, if left empty, the first configured Servarr instance listed in the config file will be used.
 ```
 
 **Pro Tip:** The CLI is even more powerful and useful when used in conjunction with the `jq` CLI tool. This allows you to parse the JSON response from the Managarr CLI and use it in your scripts; For example, to extract the `movieId` of the movie "Ad Astra", you would run:
@@ -168,72 +341,150 @@ $ managarr radarr list movies | jq '.[] | select(.title == "Ad Astra") | .id'
 Managarr assumes reasonable defaults to connect to each service (i.e. Radarr is on localhost:7878),
 but all servers will require you to input the API token.
 
-The configuration file is located somewhere different for each OS
+The configuration file is located somewhere different for each OS, so run the following command to print out the default
+location of the `managarr` configuration file for your system:
 
-### Linux
+```shell
-```
+managarr config-path
-$HOME/.config/managarr/config.yml
 ```
 
-### Mac
+## Specify Which Configuration File to Use
-```
+It can sometimes be useful to specify the configuration file you wish to use. This is useful in cases
-$HOME/Library/Application Support/managarr/config.yml
+where you may have more than one instance of a given Servarr running. Thus, you can specify the 
-```
+config file using the `--config` flag:
 
-### Windows
+```shell
-```
+managarr --config-file /path/to/config.yml
-%APPDATA%/Roaming/managarr/config.yml
 ```
 
 ### Example Configuration:
 ```yaml
+theme: default
 radarr:
-  host: 127.0.0.1
+  - host: 192.168.0.78
-  port: 7878
+    port: 7878
-  api_token: someApiToken1234567890
+    api_token: someApiToken1234567890
+    ssl_cert_path: /path/to/radarr.crt # Use a self-signed SSL certificate to connect to this Servarr
+                                       # Enables SSL regardless of the value of the 'ssl'
+
+  - host: 192.168.0.79
+    port: 7878
+    api_token: someApiToken1234567890
+    ssl: true # Use SSL to connect to this Servarr (public certs)
+    
+  - uri: http://htpc.local/radarr # Example of using the 'uri' key instead of 'host' and 'port'
+    api_token: someApiToken1234567890
+
 sonarr:
-  host: 127.0.0.1
+  - host: 192.168.0.89
-  port: 8989
+    port: 8989
-  api_token: someApiToken1234567890
+    api_token_file: /root/.config/sonarr_api_token # Example of loading the API token from a file instead of hardcoding it in the configuration file
-readarr:
+
-  host: 127.0.0.1
+  - name: Anime Sonarr # An example of a custom name for a secondary Sonarr instance
-  port: 8787
+    host: 192.168.1.89
-  api_token: someApiToken1234567890
+    port: 8989
+    api_token: someApiToken1234567890
+
 lidarr:
-  host: 127.0.0.1
+  - host: 192.168.0.86
-  port: 8686
+    port: 8686
-  api_token: someApiToken1234567890
+    api_token: ${MY_LIDARR_API_TOKEN} # Example of configuring using environment variables
-whisparr:
+    monitored_storage_paths: # Filter which Root Folders or Disk Storage you want displayed in the UI's 'Stats' block
-  host: 127.0.0.1
+      # Note: Setting these values does not affect what shows up in the 'Root Folders' tab of the UI.
-  port: 6969
+      - /nfs    # An example disk (i.e. '<servarr> list disk-space' command) you want displayed in the UI under 'Storage:'
-  api_token: someApiToken1234567890
+      - /media  # An example root folder you want displayed in the UI
-bazarr:
+                # Root folders collapse up to the super-directory to reduce duplication in the UI. For example:
-  host: 127.0.0.1
+                # if you have root folders '/media/tv', '/media/cartoons' and '/media/reality', and you set this
-  port: 6767
+                # monitored path, the UI will show '/media/[tv,cartoons,reality]' under Root Folders
-  api_token: someApiToken1234567890
+
-prowlarr:
+  - host: 192.168.1.86
-  host: 127.0.0.1
+    port: 8686
-  port: 9696
+    api_token: someApiToken1234567890
-  api_token: someApiToken1234567890
+    ssl_cert_path: /path/to/lidarr_1.crt
-tautulli:
+    custom_headers: # Example of adding custom headers to all requests to the Servarr instance
-  host: 127.0.0.1
+      traefik-auth-bypass-key: someBypassKey1234567890
-  port: 8181
+      SOME-OTHER-CUSTOM-HEADER: ${MY_CUSTOM_HEADER_VALUE}
-  api_token: someApiToken1234567890
 ```
 
-## Track My Progress for the Beta release (With Sonarr Support!)
+### Example Multi-Instance Configuration:
-Progress for the beta release can be followed on my [Wekan Board](https://wekan.alexjclarke.com/b/dHoGjBb44MHM9HSv4/managarr)
+```yaml
-with all items tagged `Beta`.
+theme: default
+radarr:
+  - host: 192.168.0.78 # No name specified, so this instance's name will default to 'Radarr 1'
+    port: 7878
+    api_token: someApiToken1234567890
+    ssl_cert_path: /path/to/radarr.crt
+    
+  - name: International Movies
+    host: 192.168.0.79
+    port: 7878
+    api_token: someApiToken1234567890
+sonarr:
+  - name: Anime
+    weight: 1 # This instance will be the first tab in the TUI
+    uri: http://htpc.local/sonarr
+    api_token: someApiToken1234567890
+
+  - name: TV Shows
+    weight: 2 # This instance will be the second tab in the TUI
+    host: 192.168.0.89
+    port: 8989
+    api_token: someApiToken1234567890
+```
+
+In this configuration, you can see that we have multiple instances of Radarr and Sonarr configured. The `weight` key is 
+used to specify the order in which the tabs will appear in the TUI. The lower the weight, the further to the left the 
+tab will appear. If no weight is specified, then tabs will be ordered in the order they appear in the configuration 
+file.
+
+When no `name` is specified for a Servarr instance, the name will default to the name of the Servarr with a number 
+appended to it. For example, if you have two Radarr instances and neither has a name, they will be named `Radarr 1` and 
+`Radarr 2`, respectively.
+
+In this example configuration, the tabs in the TUI would appear as follows:
+
+`Anime | TV Shows | Radarr 1 | International Movies`
+
+### Specify Which Servarr Instance to Use in the CLI
+If you have multiple instances of the same Servarr running, you can specify which instance you want to use by using the `--servarr-name` flag:
+
+```shell
+managarr --servarr-name "International Movies"
+```
+
+## Environment Variables
+Managarr supports using environment variables on startup so you don't have to always specify certain flags:
+
+| Variable                                | Description                                                                    | Equivalent Flag                  |
+|-----------------------------------------|--------------------------------------------------------------------------------|----------------------------------|
+| `MANAGARR_CONFIG_FILE`                  | Set the path to the config file                                                | `--config`                       |
+| `MANAGARR_DISABLE_SPINNER`              | Disable the CLI spinner (this can be useful when scripting and parsing output) | `--disable-spinner`              |
 
 ## Screenshots
 
-![library](screenshots/library.png)
+### Radarr
-![manual_search](screenshots/manual_search.png)
+![radarr_library](screenshots/radarr/radarr_library.png)
-![logs](screenshots/logs.png)
+![manual_search](screenshots/radarr/manual_search.png)
-![new_movie_search](screenshots/new_movie_search.png)
+![new_movie_search](screenshots/radarr/new_movie_search.png)
-![add_new_movie](screenshots/add_new_movie.png)
+![add_new_movie](screenshots/radarr/add_new_movie.png)
-![collection_details](screenshots/collection_details.png)
+![collection_details](screenshots/radarr/collection_details.png)
-![indexers](screenshots/indexers.png)
+
+### Sonarr
+![sonarr_library](screenshots/sonarr/sonarr_library.png)
+![series_details](screenshots/sonarr/series_details.png)
+![season_details](screenshots/sonarr/season_details.png)
+![manual_episode_search](screenshots/sonarr/manual_episode_search.png)
+
+### Lidarr
+![lidarr_library](screenshots/lidarr/lidarr_library.png)
+![artist_details](screenshots/lidarr/artist_details.png)
+![album_details](screenshots/lidarr/album_details.png)
+![artist_discography_search](screenshots/lidarr/artist_discography_search.png)
+![manual_album_search](screenshots/lidarr/manual_album_search.png)
+
+### General
+![logs](screenshots/radarr/logs.png)
+![indexers](screenshots/radarr/indexers.png)
 
 ## Dependencies
 * [ratatui](https://github.com/tui-rs-revival/ratatui)
@@ -245,9 +496,9 @@ with all items tagged `Beta`.
 
 ## Servarr Requirements
 * [Radarr >= 5.3.6.8612](https://radarr.video/docs/api/)
-* [Sonarr >= v3](https://sonarr.tv/docs/api/)
+* [Sonarr >= v4](https://sonarr.tv/docs/api/)
-* [Readarr v1](https://readarr.com/docs/api/)
 * [Lidarr v1](https://lidarr.audio/docs/api/)
+* [Readarr v1](https://readarr.com/docs/api/)
 * [Whisparr >= v3](https://whisparr.com/docs/api/)
 * [Prowlarr v1](https://prowlarr.com/docs/api/)
 * [Bazarr v1.1.4](http://localhost:6767/api)

codecov.yml

@@ -0,0 +1,14 @@
+coverage:
+  range: "80..100"
+  status:
+    project:
+      default:
+        threshold: 0
+        target: 80%
+    patch:
+      default:
+        threshold: 0
+        target: 80%
+
+ignore:
+  - "**/*_tests.rs"

deployment/chocolatey/chocolateyinstall.ps1.template

@@ -0,0 +1,20 @@
+$ErrorActionPreference = 'Stop';
+
+$PackageName = 'managarr'
+$toolsDir    = "$(Split-Path -parent $MyInvocation.MyCommand.Definition)"
+$url64       = 'https://github.com/Dark-Alex-17/managarr/releases/download/v$version/managarr-windows.tar.gz'
+$checksum64  = '$hash_64'
+
+$packageArgs = @{
+  packageName   = $packageName
+  softwareName  = $packageName
+  unzipLocation = $toolsDir
+  fileType      = 'exe'
+  url           = $url64
+  checksum      = $checksum64
+  checksumType  = 'sha256'
+
+}
+Install-ChocolateyZipPackage @packageArgs
+$File = Get-ChildItem -File -Path $env:ChocolateyInstall\lib\$packageName\tools\ -Filter *.tar
+Get-ChocolateyUnzip -fileFullPath $File.FullName -destination $env:ChocolateyInstall\lib\$packageName\tools\

deployment/chocolatey/managarr.nuspec.template

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Read this before creating packages: https://chocolatey.org/docs/create-packages -->
+<!-- It is especially important to read the above link to understand additional requirements when publishing packages to the community feed aka dot org (https://chocolatey.org/packages). -->
+
+<!-- Test your packages in a test environment: https://github.com/chocolatey/chocolatey-test-environment -->
+
+<!--
+This is a nuspec. It mostly adheres to https://docs.nuget.org/create/Nuspec-Reference. Chocolatey uses a special version of NuGet.Core that allows us to do more than was initially possible. As such there are certain things to be aware of:
+
+* the package xmlns schema url may cause issues with nuget.exe
+* Any of the following elements can ONLY be used by choco tools - projectSourceUrl, docsUrl, mailingListUrl, bugTrackerUrl, packageSourceUrl, provides, conflicts, replaces 
+* nuget.exe can still install packages with those elements but they are ignored. Any authoring tools or commands will error on those elements 
+-->
+
+<!-- You can embed software files directly into packages, as long as you are not bound by distribution rights. -->
+<!-- * If you are an organization making private packages, you probably have no issues here -->
+<!-- * If you are releasing to the community feed, you need to consider distribution rights. -->
+<!-- Do not remove this test for UTF-8: if “Ω” doesn’t appear as greek uppercase omega letter enclosed in quotation marks, you should use an editor that supports UTF-8, not this one. -->
+<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
+  <metadata>
+    <!-- == PACKAGE SPECIFIC SECTION == -->
+    <id>managarr</id>
+    <version>$version</version>
+
+    <!-- == SOFTWARE SPECIFIC SECTION == -->
+    <!-- This section is about the software itself -->
+    <title>Managarr</title>
+    <authors>Alex Clarke</authors>
+    <projectUrl>https://github.com/Dark-Alex-17/managarr</projectUrl>
+    <licenseUrl>https://github.com/Dark-Alex-17/managarr/blob/main/LICENSE</licenseUrl>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <projectSourceUrl>https://github.com/Dark-Alex-17/managarr</projectSourceUrl>
+    <docsUrl>https://github.com/Dark-Alex-17/managarr/blob/main/README.md</docsUrl>
+    <bugTrackerUrl>https://github.com/Dark-Alex-17/managarr/issues</bugTrackerUrl>
+    <tags>cli cross-platform terminal servarr tui sonarr radarr rust</tags>
+    <summary>A TUI and CLI for managing *arr servers.</summary>
+    <description>
+    A TUI and CLI for managing *arr servers. Built with love in Rust!
+
+    **Usage**
+    To use, run `managarr` in a terminal.
+    
+    For more [documentation and usage](https://github.com/Dark-Alex-17/managarr/blob/main/README.md), see the [official repo](https://github.com/Dark-Alex-17/managarr).
+    
+    </description>
+    <releaseNotes>https://github.com/Dark-Alex-17/managarr/releases/tag/v$version/</releaseNotes>
+  </metadata>
+  <files>
+    <!-- this section controls what actually gets packaged into the Chocolatey package -->
+    <file src="tools\**" target="tools" />
+    <!--Building from Linux? You may need this instead: <file src="tools/**" target="tools" />-->
+  </files>
+</package>

deployment/chocolatey/packager.py

@@ -0,0 +1,28 @@
+import hashlib
+import sys
+from string import Template
+
+sys.stdout.reconfigure(encoding='utf-8')
+args = sys.argv
+version = args[1].replace("v", "")
+template_file_path = args[2]
+generated_file_path = args[3]
+
+# Deployment files
+hash_64 = args[4].strip()
+
+print("Generating formula")
+print("     VERSION: %s" % version)
+print("     TEMPLATE PATH: %s" % template_file_path)
+print("     SAVING AT: %s" % generated_file_path)
+print("     HASH: %s" % hash_64)
+
+with open(template_file_path, "r", encoding="utf-8") as template_file:
+    template = Template(template_file.read())
+    substitute = template.safe_substitute(version=version, hash_64=hash_64)
+    print("\n================== Generated package file ==================\n")
+    print(substitute)
+    print("\n============================================================\n")
+
+    with open(generated_file_path, "w", encoding="utf-8") as generated_file:
+        generated_file.write(substitute)

deployment/homebrew/managarr.rb.template

@@ -0,0 +1,24 @@
+# Documentation: https://docs.brew.sh/Formula-Cookbook
+#                https://rubydoc.brew.sh/Formula
+class Managarr < Formula
+  desc "Managarr is a TUI and CLI to help you manage your HTPC (Home Theater PC)"
+  homepage "https://github.com/Dark-Alex-17/managarr"
+  if OS.mac? and Hardware::CPU.arm?
+    url "https://github.com/Dark-Alex-17/managarr/releases/download/v$version/managarr-macos-arm64.tar.gz"
+    sha256 "$hash_mac_arm"
+  elsif OS.mac? and Hardware::CPU.intel?
+    url "https://github.com/Dark-Alex-17/managarr/releases/download/v$version/managarr-macos.tar.gz"
+    sha256 "$hash_mac"
+  else
+    url "https://github.com/Dark-Alex-17/managarr/releases/download/v$version/managarr-linux-musl.tar.gz"
+    sha256 "$hash_linux"
+  end
+  version "$version"
+  license "MIT"
+
+  def install
+    bin.install "managarr"
+    ohai "You're done!  Run with \"managarr\""
+    ohai "For runtime flags, see \"managarr --help\""
+  end
+end

deployment/homebrew/packager.py

@@ -0,0 +1,31 @@
+import hashlib
+import sys
+from string import Template
+
+args = sys.argv
+version = args[1]
+template_file_path = args[2]
+generated_file_path = args[3]
+
+# Deployment files
+hash_mac = args[4].strip()
+hash_mac_arm = args[5].strip()
+hash_linux = args[6].strip()
+
+print("Generating formula")
+print("     VERSION: %s" % version)
+print("     TEMPLATE PATH: %s" % template_file_path)
+print("     SAVING AT: %s" % generated_file_path)
+print("     MAC HASH: %s" % hash_mac)
+print("     MAC ARM HASH: %s" % hash_mac_arm)
+print("     LINUX HASH: %s" % hash_linux)
+
+with open(template_file_path, "r") as template_file:
+    template = Template(template_file.read())
+    substitute = template.safe_substitute(version=version, hash_mac=hash_mac, hash_mac_arm=hash_mac_arm, hash_linux=hash_linux)
+    print("\n================== Generated package file ==================\n")
+    print(substitute)
+    print("\n============================================================\n")
+
+    with open(generated_file_path, "w") as generated_file:
+        generated_file.write(substitute)

justfile

@@ -0,0 +1,89 @@
+VERSION := "latest"
+IMG_NAME := "darkalex17/managarr"
+
+# List all recipes
+default:
+    @just --list
+
+# Format all files
+[group: 'style']
+fmt:
+    @cargo fmt --all
+
+alias clippy := lint
+# Run Clippy to inspect all files
+[group: 'style']
+lint:
+    @cargo clippy --all
+
+alias clippy-fix := lint-fix
+# Automatically fix clippy issues where possible
+[group: 'style']
+lint-fix:
+    @cargo fix
+
+# Analyze the project for unsafe usage
+[group: 'style']
+@analyze:
+    #!/usr/bin/env bash
+    cargo geiger -h > /dev/null 2>&1 | cargo install cargo-geiger
+    cargo geiger
+
+# Run all tests
+[group: 'test']
+test:
+    @cargo test --all
+
+# Run all tests with coverage
+[group:'test']
+@test-cov:
+    #!/usr/bin/env bash
+    cargo tarpaulin -h > /dev/null 2>&1 || cargo install cargo-tarpaulin
+    cargo tarpaulin
+
+# Run all doc tests
+[group: 'test']
+doctest:
+    @cargo test --all --doc
+
+# Run all proptests
+[group: 'test']
+proptest:
+    @cargo test proptest
+
+alias test-snapshots := snapshot-tests
+# Run all snapshot tests
+[group: 'test']
+snapshot-tests:
+    @cargo test snapshot
+
+alias review := snapshot-review
+# Review snapshot test changes
+[group: 'test']
+@snapshot-review:
+    #!/usr/bin/env bash
+    cargo insta -h > /dev/null 2>&1 || cargo install cargo-insta
+    cargo insta review
+
+alias clean-orphaned-snapshots := snapshot-delete-unreferenced
+# Delete any unreferenced snapshots
+[group: 'test']
+@snapshot-delete-unreferenced:
+    #!/usr/bin/env bash
+    cargo insta -h > /dev/null 2>&1 || cargo install cargo-insta
+    cargo insta test --unreferenced=delete
+
+# Build and run the binary for the current system
+run:
+    @cargo run
+
+# Build the project for the current system architecture
+[group: 'build']
+[arg('build_type', pattern="debug|release")]
+build build_type='debug':
+    @cargo build {{ if build_type == "release" { "--release" } else { "" } }}
+
+# Build the docker image
+[group: 'build']
+build-docker:
+    @DOCKER_BUILDKIT=1 docker build --rm -t {{IMG_NAME}}:{{VERSION}} .

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "managarr",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package.json

@@ -0,0 +1 @@
+{}

proc_macros/enum_display_style_derive/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "enum_display_style_derive"
+version = "0.6.1"
+edition = "2024"
+authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
+description = "A proc-macro to derive a `Display` and `FromStr` implementation for enums with a `style` attribute."
+license = "MIT"
+documentation = "https://github.com/Dark-Alex-17/managarr"
+repository = "https://github.com/Dark-Alex-17/managarr"
+homepage = "https://github.com/Dark-Alex-17/managarr"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.39"
+syn = "2.0.99"
+darling = "0.20.10"

proc_macros/enum_display_style_derive/src/lib.rs

@@ -0,0 +1,76 @@
+mod macro_models;
+
+use crate::macro_models::DisplayStyleArgs;
+use darling::FromVariant;
+use quote::quote;
+use syn::{Data, DeriveInput, parse_macro_input};
+
+/// Derive macro for generating a `to_display_str` method for an enum.
+///
+/// # Example
+///
+/// Using default values for the display style:
+///
+/// ```
+/// use enum_display_style_derive::EnumDisplayStyle;
+///
+/// #[derive(EnumDisplayStyle)]
+/// enum Weekend {
+///     Saturday,
+///     Sunday,
+/// }
+///
+/// assert_eq!(Weekend::Saturday.to_display_str(), "Saturday");
+/// assert_eq!(Weekend::Sunday.to_display_str(), "Sunday");
+/// ```
+///
+/// Using custom values for the display style:
+///
+/// ```
+/// use enum_display_style_derive::EnumDisplayStyle;
+///
+/// #[derive(EnumDisplayStyle)]
+/// enum MonitorStatus {
+///     #[display_style(name = "Monitor Transactions")]
+///     Active,
+///     #[display_style(name = "Don't Monitor Transactions")]
+///     None,
+/// }
+///
+/// assert_eq!(MonitorStatus::Active.to_display_str(), "Monitor Transactions");
+/// assert_eq!(MonitorStatus::None.to_display_str(), "Don't Monitor Transactions");
+/// ```
+#[proc_macro_derive(EnumDisplayStyle, attributes(display_style))]
+pub fn enum_display_style_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+  let input = parse_macro_input!(input as DeriveInput);
+  let enum_name = &input.ident;
+
+  let mut match_arms = Vec::new();
+
+  if let Data::Enum(data_enum) = &input.data {
+    let variants = &data_enum.variants;
+
+    for variant in variants {
+      let variant_ident = &variant.ident;
+      let variant_display_name = DisplayStyleArgs::from_variant(variant)
+        .unwrap()
+        .name
+        .unwrap_or_else(|| variant_ident.to_string());
+
+      match_arms.push(quote! {
+        #enum_name::#variant_ident => #variant_display_name,
+      });
+    }
+  }
+
+  quote! {
+    impl<'a> #enum_name {
+      pub fn to_display_str(self) -> &'a str {
+        match self {
+          #(#match_arms)*
+        }
+      }
+    }
+  }
+  .into()
+}

proc_macros/enum_display_style_derive/src/macro_models.rs

@@ -0,0 +1,7 @@
+use darling::FromVariant;
+
+#[derive(Debug, FromVariant)]
+#[darling(attributes(display_style))]
+pub struct DisplayStyleArgs {
+  pub name: Option<String>,
+}

proc_macros/validate_theme_derive/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "validate_theme_derive"
+version = "0.6.1"
+edition = "2024"
+authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
+description = "A proc-macro to validate a theme."
+license = "MIT"
+documentation = "https://github.com/Dark-Alex-17/managarr"
+repository = "https://github.com/Dark-Alex-17/managarr"
+homepage = "https://github.com/Dark-Alex-17/managarr"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.39"
+syn = "2.0.99"
+
+[dev-dependencies]
+log = "0.4.17"

proc_macros/validate_theme_derive/src/lib.rs

@@ -0,0 +1,106 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, parse_macro_input};
+
+/// Derive macro for generating a `validate` method for a Theme struct.
+/// The `validate` method ensures that all values with the `validate` attribute are not `None`.
+/// Otherwise, an error message it output to both the log file and stdout and the program exits.
+///
+/// # Example
+///
+/// Valid themes pass through the program transitively without any messages being output.
+///
+/// ```
+/// use validate_theme_derive::ValidateTheme;
+///
+/// #[derive(ValidateTheme, Default)]
+/// struct Theme {
+///     pub name: String,
+///     #[validate]
+///     pub good: Option<Style>,
+///     #[validate]
+///     pub bad: Option<Style>,
+///     pub ugly: Option<Style>,
+/// }
+///
+/// struct Style {
+///     color: String,
+/// }
+///
+/// let theme = Theme {
+///     good: Some(Style { color: "Green".to_owned() }),
+///     bad: Some(Style { color: "Red".to_owned() }),
+///     ..Theme::default()
+/// };
+///
+/// // Since only `good` and `bad` have the `validate` attribute, the `validate` method will only check those fields.
+/// theme.validate();
+/// // Since both `good` and `bad` have values, the program will not exit and no message is output.
+/// ```
+///
+/// Invalid themes will output an error message to both the log file and stdout and the program will exit.
+///
+/// ```should_panic
+/// use validate_theme_derive::ValidateTheme;
+///
+/// #[derive(ValidateTheme, Default)]
+/// struct Theme {
+///     pub name: String,
+///     #[validate]
+///     pub good: Option<Style>,
+///     #[validate]
+///     pub bad: Option<Style>,
+///     pub ugly: Option<Style>,
+/// }
+///
+/// struct Style {
+///     color: String,
+/// }
+///
+/// let theme = Theme {
+///     bad: Some(Style { color: "Red".to_owned() }),
+///     ..Theme::default()
+/// };
+///
+/// // Since `good` has the `validate` attribute and since `good` is `None`, the `validate` method will output an error message and exit the program.
+/// theme.validate();
+/// ```
+#[proc_macro_derive(ValidateTheme, attributes(validate))]
+pub fn derive_validate_theme(input: TokenStream) -> TokenStream {
+  let input = parse_macro_input!(input as DeriveInput);
+  let struct_name = &input.ident;
+
+  let mut validation_checks = Vec::new();
+
+  if let Data::Struct(data_struct) = &input.data
+    && let Fields::Named(fields) = &data_struct.fields
+  {
+    for field in &fields.named {
+      let field_name = &field.ident;
+
+      let has_validate_attr = field
+        .attrs
+        .iter()
+        .any(|attr| attr.path().is_ident("validate"));
+
+      if has_validate_attr {
+        validation_checks.push(quote! {
+          if self.#field_name.is_none() {
+            log::error!("{} is missing a color value.", stringify!(#field_name));
+            eprintln!("{} is missing a color value.", stringify!(#field_name));
+            std::process::exit(1);
+          }
+        })
+      }
+    }
+  }
+
+  quote! {
+    impl #struct_name {
+      pub fn validate(&self) {
+        #(#validation_checks)*
+      }
+    }
+  }
+  .into()
+}

proptest-regressions/handlers/handler_proptest.txt

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 56330c025ad79db641d0eb9f429ab74e95822e1fb015b58f0e158ea674cd42a1 # shrinks to list_size = 1, page_ops = 1

proptest-regressions/handlers/table_handler_tests.txt

@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc fb4b58aa3015a125fc33a78dfaf27981db4191247151b327a351fc445e07c231 # shrinks to input = "j"
+cc d6ec17d4d3f635f0a095ade650a316d26abc1f9fe2b6d9cf67bf2f8b4ebedb60 # shrinks to backspace_count = 0
+cc cd46ee46e18cf86c940fb89c7206f0b482909880b8f2eabe3dd20682b9912c8a # shrinks to input = "h"

proptest-regressions/ui/ui_property_tests.txt

@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 24ae243412a324cb46c36cb4f629ddd4c9326b1479d1186d9b5545ac5e86dbba # shrinks to num_scroll_attempts = 0
+cc c06a1cc1e4740b2498c50d7be64715bf09ef3ac4cf3bb3642f960578a3e06c74 # shrinks to is_loading = false, num_items = 1
+cc 930207899afea2d389c7fa3974e31c2eb1803e71bcbd8179246c795903905ec7 # shrinks to parent_width = 20, parent_height = 12, percent_x = 1, percent_y = 1

rustfmt.toml

@@ -1,5 +1,5 @@
 tab_spaces=2
-edition = "2021"
+edition = "2024"
 reorder_imports = true
 imports_granularity = "Crate"
 group_imports = "StdExternalCrate"

src/app/app_tests.rs

@@ -2,65 +2,124 @@
 mod tests {
   use anyhow::anyhow;
   use pretty_assertions::{assert_eq, assert_str_eq};
+  use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
+  use serde_json::Value;
+  use serial_test::serial;
   use tokio::sync::mpsc;
 
-  use crate::app::context_clues::{build_context_clue_string, SERVARR_CONTEXT_CLUES};
+  use crate::app::{App, AppConfig, Data, ServarrConfig, interpolate_env_vars};
-  use crate::app::{App, Data, RadarrConfig, DEFAULT_ROUTE};
+  use crate::models::servarr_data::lidarr::lidarr_data::LidarrData;
   use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
-  use crate::models::{HorizontallyScrollableText, Route, TabRoute};
+  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
-  use crate::network::radarr_network::RadarrEvent;
+  use crate::models::{HorizontallyScrollableText, TabRoute};
   use crate::network::NetworkEvent;
+  use crate::network::radarr_network::RadarrEvent;
+  use tokio_util::sync::CancellationToken;
+
+  #[test]
+  fn test_app_new() {
+    let radarr_config_1 = ServarrConfig {
+      name: Some("Radarr Test".to_owned()),
+      ..ServarrConfig::default()
+    };
+    let radarr_config_2 = ServarrConfig {
+      weight: Some(3),
+      ..ServarrConfig::default()
+    };
+    let sonarr_config_1 = ServarrConfig {
+      name: Some("Sonarr Test".to_owned()),
+      weight: Some(1),
+      ..ServarrConfig::default()
+    };
+    let sonarr_config_2 = ServarrConfig::default();
+    let config = AppConfig {
+      theme: None,
+      radarr: Some(vec![radarr_config_1.clone(), radarr_config_2.clone()]),
+      sonarr: Some(vec![sonarr_config_1.clone(), sonarr_config_2.clone()]),
+      lidarr: None,
+    };
+    let expected_tab_routes = vec![
+      TabRoute {
+        title: "Sonarr Test".to_owned(),
+        route: ActiveSonarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(sonarr_config_1),
+      },
+      TabRoute {
+        title: "Radarr 1".to_owned(),
+        route: ActiveRadarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(radarr_config_2),
+      },
+      TabRoute {
+        title: "Radarr Test".to_owned(),
+        route: ActiveRadarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(radarr_config_1),
+      },
+      TabRoute {
+        title: "Sonarr 1".to_owned(),
+        route: ActiveSonarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(sonarr_config_2),
+      },
+    ];
+
+    let app = App::new(
+      mpsc::channel::<NetworkEvent>(500).0,
+      config,
+      CancellationToken::new(),
+    );
+
+    assert_is_empty!(app.navigation_stack);
+    assert_eq!(app.get_current_route(), ActiveSonarrBlock::default().into());
+    assert_some!(app.network_tx);
+    assert!(!app.cancellation_token.is_cancelled());
+    assert!(app.is_first_render);
+    assert_eq!(app.error, HorizontallyScrollableText::default());
+    assert_eq!(app.server_tabs.index, 0);
+    assert_eq!(app.server_tabs.tabs, expected_tab_routes);
+    assert_eq!(app.tick_until_poll, 400);
+    assert_eq!(app.ticks_until_scroll, 64);
+    assert_eq!(app.tick_count, 0);
+    assert_eq!(app.ui_scroll_tick_count, 0);
+    assert!(!app.is_loading);
+    assert!(!app.is_routing);
+    assert!(!app.should_refresh);
+    assert!(!app.ignore_special_keys_for_textbox_input);
+    assert!(!app.cli_mode);
+  }
 
   #[test]
   fn test_app_default() {
     let app = App::default();
 
-    assert_eq!(app.navigation_stack, vec![DEFAULT_ROUTE]);
+    assert_is_empty!(app.navigation_stack);
-    assert!(app.network_tx.is_none());
+    assert_none!(app.network_tx);
     assert!(!app.cancellation_token.is_cancelled());
+    assert!(app.is_first_render);
     assert_eq!(app.error, HorizontallyScrollableText::default());
     assert_eq!(app.server_tabs.index, 0);
-    assert_eq!(
-      app.server_tabs.tabs,
-      vec![
-        TabRoute {
-          title: "Radarr",
-          route: ActiveRadarrBlock::Movies.into(),
-          help: format!(
-            "<↑↓> scroll | ←→ change tab | {}  ",
-            build_context_clue_string(&SERVARR_CONTEXT_CLUES)
-          ),
-          contextual_help: None,
-        },
-        TabRoute {
-          title: "Sonarr",
-          route: Route::Sonarr,
-          help: format!("{}  ", build_context_clue_string(&SERVARR_CONTEXT_CLUES)),
-          contextual_help: None,
-        },
-      ]
-    );
     assert_eq!(app.tick_until_poll, 400);
-    assert_eq!(app.ticks_until_scroll, 4);
+    assert_eq!(app.ticks_until_scroll, 64);
     assert_eq!(app.tick_count, 0);
     assert!(!app.is_loading);
     assert!(!app.is_routing);
     assert!(!app.should_refresh);
-    assert!(!app.should_ignore_quit_key);
+    assert!(!app.ignore_special_keys_for_textbox_input);
+    assert!(!app.cli_mode);
   }
 
   #[test]
   fn test_navigation_stack_methods() {
-    let mut app = App::default();
+    let mut app = App::test_default();
+    let default_route = app.server_tabs.tabs.first().unwrap().route;
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
 
     app.push_navigation_stack(ActiveRadarrBlock::Downloads.into());
 
-    assert_eq!(
+    assert_eq!(app.get_current_route(), ActiveRadarrBlock::Downloads.into());
-      app.get_current_route(),
-      &ActiveRadarrBlock::Downloads.into()
-    );
     assert!(app.is_routing);
 
     app.is_routing = false;
@@ -68,26 +127,30 @@ mod tests {
 
     assert_eq!(
       app.get_current_route(),
-      &ActiveRadarrBlock::Collections.into()
+      ActiveRadarrBlock::Collections.into()
     );
     assert!(app.is_routing);
 
     app.is_routing = false;
     app.pop_navigation_stack();
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
     assert!(app.is_routing);
 
     app.is_routing = false;
     app.pop_navigation_stack();
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
     assert!(app.is_routing);
   }
 
   #[test]
   fn test_reset_cancellation_token() {
-    let mut app = App::default();
+    let mut app = App {
+      is_loading: true,
+      should_refresh: false,
+      ..App::test_default()
+    };
     app.cancellation_token.cancel();
 
     assert!(app.cancellation_token.is_cancelled());
@@ -96,13 +159,15 @@ mod tests {
 
     assert!(!app.cancellation_token.is_cancelled());
     assert!(!new_token.is_cancelled());
+    assert!(!app.is_loading);
+    assert!(app.should_refresh);
   }
 
   #[test]
   fn test_reset_tick_count() {
     let mut app = App {
       tick_count: 2,
-      ..App::default()
+      ..App::test_default()
     };
 
     app.reset_tick_count();
@@ -112,28 +177,39 @@ mod tests {
 
   #[test]
   fn test_reset() {
+    let radarr_data = RadarrData {
+      version: "test".into(),
+      ..RadarrData::default()
+    };
+    let sonarr_data = SonarrData {
+      version: "test".into(),
+      ..SonarrData::default()
+    };
+    let data = Data {
+      lidarr_data: LidarrData::default(),
+      radarr_data,
+      sonarr_data,
+    };
     let mut app = App {
       tick_count: 2,
       error: "Test error".to_owned().into(),
-      data: Data {
+      is_first_render: false,
-        radarr_data: RadarrData {
+      data,
-          version: "test".to_owned(),
+      ..App::test_default()
-          ..RadarrData::default()
-        },
-      },
-      ..App::default()
     };
 
     app.reset();
 
     assert_eq!(app.tick_count, 0);
     assert_eq!(app.error, HorizontallyScrollableText::default());
+    assert!(app.is_first_render);
     assert!(app.data.radarr_data.version.is_empty());
+    assert!(app.data.sonarr_data.version.is_empty());
   }
 
   #[test]
   fn test_handle_error() {
-    let mut app = App::default();
+    let mut app = App::test_default();
     let test_string = "Testing";
 
     app.handle_error(anyhow!(test_string));
@@ -145,6 +221,50 @@ mod tests {
     assert_eq!(app.error.text, test_string);
   }
 
+  #[tokio::test]
+  async fn test_dispatch_network_event() {
+    let (sync_network_tx, mut sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
+
+    let mut app = App {
+      tick_until_poll: 2,
+      network_tx: Some(sync_network_tx),
+      ..App::test_default()
+    };
+
+    assert_eq!(app.tick_count, 0);
+
+    app
+      .dispatch_network_event(RadarrEvent::GetStatus.into())
+      .await;
+
+    assert_eq!(
+      sync_network_rx.recv().await.unwrap(),
+      RadarrEvent::GetStatus.into()
+    );
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[test]
+  fn test_on_ui_scroll_tick() {
+    let mut app = App {
+      ticks_until_scroll: 1,
+      ..App::default()
+    };
+
+    assert_eq!(app.ui_scroll_tick_count, 0);
+    assert_eq!(app.tick_count, 0);
+
+    app.on_ui_scroll_tick();
+
+    assert_eq!(app.ui_scroll_tick_count, 1);
+    assert_eq!(app.tick_count, 0);
+
+    app.on_ui_scroll_tick();
+
+    assert_eq!(app.ui_scroll_tick_count, 0);
+    assert_eq!(app.tick_count, 0);
+  }
+
   #[tokio::test]
   async fn test_on_tick_first_render() {
     let (sync_network_tx, mut sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
@@ -152,12 +272,14 @@ mod tests {
     let mut app = App {
       tick_until_poll: 2,
       network_tx: Some(sync_network_tx),
-      ..App::default()
+      is_first_render: true,
+      ..App::test_default()
     };
 
     assert_eq!(app.tick_count, 0);
 
-    app.on_tick(true).await;
+    app.on_tick().await;
+
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
       RadarrEvent::GetQualityProfiles.into()
@@ -172,7 +294,11 @@ mod tests {
     );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetOverview.into()
+      RadarrEvent::GetDownloads(500).into()
+    );
+    assert_eq!(
+      sync_network_rx.recv().await.unwrap(),
+      RadarrEvent::GetDiskSpace.into()
     );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
@@ -180,11 +306,15 @@ mod tests {
     );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetMovies.into()
+      RadarrEvent::GetQualityProfiles.into()
     );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetTags.into()
+    );
+    assert_eq!(
+      sync_network_rx.recv().await.unwrap(),
+      RadarrEvent::GetMovies.into()
     );
     assert!(!app.is_routing);
     assert!(!app.should_refresh);
@@ -197,10 +327,10 @@ mod tests {
       tick_until_poll: 2,
       tick_count: 2,
       is_routing: true,
-      ..App::default()
+      ..App::test_default()
     };
 
-    app.on_tick(false).await;
+    app.on_tick().await;
     assert!(!app.is_routing);
   }
 
@@ -210,19 +340,428 @@ mod tests {
       tick_until_poll: 2,
       tick_count: 2,
       should_refresh: true,
-      ..App::default()
+      ..App::test_default()
     };
 
-    app.on_tick(false).await;
+    app.on_tick().await;
     assert!(!app.should_refresh);
   }
 
   #[test]
-  fn test_radarr_config_default() {
+  fn test_app_config_default() {
-    let radarr_config = RadarrConfig::default();
+    let app_config = AppConfig::default();
 
-    assert_str_eq!(radarr_config.host, "localhost");
+    assert_none!(app_config.radarr);
-    assert_eq!(radarr_config.port, Some(7878));
+    assert_none!(app_config.sonarr);
-    assert!(radarr_config.api_token.is_empty());
+  }
+
+  #[test]
+  fn test_servarr_config_default() {
+    let servarr_config = ServarrConfig::default();
+
+    assert_none!(servarr_config.name);
+    assert_some_eq_x!(&servarr_config.host, "localhost");
+    assert_none!(servarr_config.port);
+    assert_none!(servarr_config.uri);
+    assert_none!(servarr_config.weight);
+    assert_some_eq_x!(&servarr_config.api_token, "");
+    assert_none!(servarr_config.api_token_file);
+    assert_none!(servarr_config.ssl_cert_path);
+    assert_none!(servarr_config.custom_headers);
+  }
+
+  #[test]
+  fn serialize_header_map_basic() {
+    let mut header_map = HeaderMap::new();
+    header_map.insert(
+      HeaderName::from_static("x-api-key"),
+      HeaderValue::from_static("abc123"),
+    );
+    header_map.insert(
+      HeaderName::from_static("header-1"),
+      HeaderValue::from_static("test"),
+    );
+
+    let config = ServarrConfig {
+      custom_headers: Some(header_map),
+      ..ServarrConfig::default()
+    };
+
+    let v: Value = serde_json::to_value(&config).expect("serialize ok");
+    let custom = v.get("custom_headers").unwrap();
+    assert!(custom.is_object());
+    let obj = custom.as_object().unwrap();
+
+    assert_some_eq_x!(obj.get("x-api-key"), "abc123");
+    assert_some_eq_x!(obj.get("header-1"), "test");
+
+    assert_none!(obj.get("X-Api-Key"));
+    assert_none!(obj.get("HEADER-1"));
+  }
+
+  #[test]
+  fn serialize_header_map_none_is_null() {
+    let config = ServarrConfig::default();
+    let v: Value = serde_json::to_value(&config).expect("serialize ok");
+    assert!(v.get("custom_headers").unwrap().is_null());
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION", "localhost") };
+    let yaml_data = r#"
+      host: ${TEST_VAR_DESERIALIZE_OPTION}
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.host, "localhost");
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_does_not_overwrite_non_env_value() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_NO_OVERWRITE", "localhost") };
+    let yaml_data = r#"
+      host: www.example.com
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.host, "www.example.com");
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_NO_OVERWRITE") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_env_var_empty() {
+    let yaml_data = r#"
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.port);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_bool_is_bool() {
+    let yaml_data = r#"
+      host: localhost
+      api_token: "test123"
+      ssl: true
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.ssl, &true);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_bool_is_string() {
+    let yaml_data = r#"
+      host: localhost
+      api_token: "test123"
+      ssl: "true"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.ssl, &true);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_bool_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_BOOL", "true") };
+    let yaml_data = r#"
+      host: localhost
+      api_token: "test123"
+      ssl: ${TEST_VAR_DESERIALIZE_OPTION_BOOL}
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.ssl, &true);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_BOOL") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_bool_defaults_to_false() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_BOOL_FALSEY", "test") };
+    let yaml_data = r#"
+      host: localhost
+      api_token: "test123"
+      ssl: ${TEST_VAR_DESERIALIZE_OPTION_BOOL_FALSEY}
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.ssl, &false);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_BOOL_FALSEY") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_env_var_bool_empty() {
+    let yaml_data = r#"
+      host: localhost
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.ssl);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_header_map_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_HEADER_OPTION", "localhost") };
+    let expected_custom_headers = {
+      let mut headers = HeaderMap::new();
+      headers.insert("X-Api-Host", "localhost".parse().unwrap());
+      headers.insert("api-token", "test123".parse().unwrap());
+      headers
+    };
+    let yaml_data = r#"
+      custom_headers:
+        X-Api-Host: ${TEST_VAR_DESERIALIZE_HEADER_OPTION}
+        api-token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.custom_headers, &expected_custom_headers);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_HEADER_OPTION") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_header_map_does_not_overwrite_non_env_value() {
+    unsafe {
+      std::env::set_var(
+        "TEST_VAR_DESERIALIZE_HEADER_OPTION_NO_OVERWRITE",
+        "localhost",
+      )
+    };
+    let expected_custom_headers = {
+      let mut headers = HeaderMap::new();
+      headers.insert("X-Api-Host", "www.example.com".parse().unwrap());
+      headers.insert("api-token", "test123".parse().unwrap());
+      headers
+    };
+    let yaml_data = r#"
+      custom_headers:
+        X-Api-Host: www.example.com
+        api-token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.custom_headers, &expected_custom_headers);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_HEADER_OPTION_NO_OVERWRITE") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_env_var_header_map_empty() {
+    let yaml_data = r#"
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.custom_headers);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_string_vec_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_STRING_VEC_OPTION", "/path1") };
+    let expected_monitored_paths = ["/path1", "/path2"];
+    let yaml_data = r#"
+      monitored_storage_paths:
+        - ${TEST_VAR_DESERIALIZE_STRING_VEC_OPTION}
+        - /path2
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.monitored_storage_paths, &expected_monitored_paths);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_STRING_VEC_OPTION") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_string_vec_does_not_overwrite_non_env_value() {
+    unsafe {
+      std::env::set_var(
+        "TEST_VAR_DESERIALIZE_STRING_VEC_OPTION_NO_OVERWRITE",
+        "/path3",
+      )
+    };
+    let expected_monitored_paths = ["/path1", "/path2"];
+    let yaml_data = r#"
+      monitored_storage_paths:
+        - /path1
+        - /path2
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.monitored_storage_paths, &expected_monitored_paths);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_STRING_VEC_OPTION_NO_OVERWRITE") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_env_var_string_vec_empty() {
+    let yaml_data = r#"
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.monitored_storage_paths);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_u16_env_var_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_U16", "1") };
+    let yaml_data = r#"
+      port: ${TEST_VAR_DESERIALIZE_OPTION_U16}
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(config.port, 1);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_U16") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_u16_env_var_does_not_overwrite_non_env_value() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_U16_UNUSED", "1") };
+    let yaml_data = r#"
+      port: 1234
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(config.port, 1234);
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_U16_UNUSED") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_u16_env_var_invalid_number() {
+    let yaml_data = r#"
+      port: "hi"
+      api_token: "test123"
+    "#;
+    let result: Result<ServarrConfig, _> = serde_yaml::from_str(yaml_data);
+
+    assert_err!(&result);
+    let err = result.unwrap_err().to_string();
+    assert_contains!(err, "invalid digit found in string");
+  }
+
+  #[test]
+  fn test_deserialize_optional_u16_env_var_empty() {
+    let yaml_data = r#"
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.port);
+  }
+
+  #[test]
+  #[serial]
+  fn test_interpolate_env_vars() {
+    unsafe { std::env::set_var("TEST_VAR_INTERPOLATION", "testing") };
+
+    let var = interpolate_env_vars("${TEST_VAR_INTERPOLATION}");
+
+    assert_str_eq!(var, "testing");
+    unsafe { std::env::remove_var("TEST_VAR_INTERPOLATION") };
+  }
+
+  #[test]
+  fn test_interpolate_env_vars_defaults_to_original_string_if_not_in_yaml_interpolation_format() {
+    let var = interpolate_env_vars("TEST_VAR_INTERPOLATION_NON_YAML");
+
+    assert_str_eq!(var, "TEST_VAR_INTERPOLATION_NON_YAML");
+  }
+
+  #[test]
+  #[serial]
+  fn test_interpolate_env_vars_scrubs_all_unnecessary_characters() {
+    unsafe {
+      std::env::set_var(
+        "TEST_VAR_INTERPOLATION_UNNECESSARY_CHARACTERS",
+        r#"""
+	        `"'https://dontdo:this@testing.com/query?test=%20query#results'"` {([\|$!])}
+      """#,
+      )
+    };
+
+    let var = interpolate_env_vars("${TEST_VAR_INTERPOLATION_UNNECESSARY_CHARACTERS}");
+
+    assert_str_eq!(
+      var,
+      "https://dontdo:this@testing.com/query?test=%20query#results"
+    );
+    unsafe { std::env::remove_var("TEST_VAR_INTERPOLATION_UNNECESSARY_CHARACTERS") };
+  }
+
+  #[test]
+  fn test_interpolate_env_vars_scrubs_all_unnecessary_characters_from_non_environment_variable() {
+    let var = interpolate_env_vars("https://dontdo:this@testing.com/query?test=%20query#results");
+
+    assert_str_eq!(
+      var,
+      "https://dontdo:this@testing.com/query?test=%20query#results"
+    );
+  }
+
+  #[test]
+  fn test_servarr_config_redacted_debug() {
+    let name = "Servarr".to_owned();
+    let host = "localhost".to_owned();
+    let port = 1234;
+    let uri = "http://localhost:1234".to_owned();
+    let weight = 100;
+    let api_token = "thisisatest".to_owned();
+    let api_token_file = "/root/.config/api_token".to_owned();
+    let ssl_cert_path = "/some/path".to_owned();
+    let monitored_storage = vec!["/path1".to_owned(), "/path2".to_owned()];
+    let mut custom_headers = HeaderMap::new();
+    custom_headers.insert("X-Custom-Header", "value".parse().unwrap());
+    let expected_str = format!(
+      "ServarrConfig {{ name: Some(\"{name}\"), host: Some(\"{host}\"), port: Some({port}), uri: Some(\"{uri}\"), weight: Some({weight}), api_token: Some(\"***********\"), api_token_file: Some(\"{api_token_file}\"), ssl: Some(true), ssl_cert_path: Some(\"{ssl_cert_path}\"), custom_headers: Some({{\"x-custom-header\": \"value\"}}), monitored_storage_paths: Some([\"/path1\", \"/path2\"]) }}"
+    );
+    let servarr_config = ServarrConfig {
+      name: Some(name),
+      host: Some(host),
+      port: Some(port),
+      uri: Some(uri),
+      weight: Some(weight),
+      api_token: Some(api_token),
+      api_token_file: Some(api_token_file),
+      ssl_cert_path: Some(ssl_cert_path),
+      ssl: Some(true),
+      custom_headers: Some(custom_headers),
+      monitored_storage_paths: Some(monitored_storage),
+    };
+
+    assert_str_eq!(format!("{servarr_config:?}"), expected_str);
   }
 }

src/app/context_clues.rs

@@ -1,23 +1,131 @@
-use crate::app::key_binding::{KeyBinding, DEFAULT_KEYBINDINGS};
+use crate::app::App;
+use crate::app::key_binding::{DEFAULT_KEYBINDINGS, KeyBinding};
+use crate::app::lidarr::lidarr_context_clues::LidarrContextClueProvider;
+use crate::app::radarr::radarr_context_clues::RadarrContextClueProvider;
+use crate::app::sonarr::sonarr_context_clues::SonarrContextClueProvider;
+use crate::models::Route;
 
 #[cfg(test)]
 #[path = "context_clues_tests.rs"]
 mod context_clues_tests;
 
-pub(in crate::app) type ContextClue = (KeyBinding, &'static str);
+pub type ContextClue = (KeyBinding, &'static str);
 
-pub fn build_context_clue_string(context_clues: &[(KeyBinding, &str)]) -> String {
+pub trait ContextClueProvider {
-  context_clues
+  fn get_context_clues(_app: &mut App<'_>) -> Option<&'static [ContextClue]>;
-    .iter()
-    .map(|(key_binding, desc)| format!("{} {desc}", key_binding.key))
-    .collect::<Vec<String>>()
-    .join(" | ")
 }
 
-pub static SERVARR_CONTEXT_CLUES: [ContextClue; 2] = [
+pub struct ServarrContextClueProvider;
-  (DEFAULT_KEYBINDINGS.tab, "change servarr"),
+
+impl ContextClueProvider for ServarrContextClueProvider {
+  fn get_context_clues(app: &mut App<'_>) -> Option<&'static [ContextClue]> {
+    match app.get_current_route() {
+      Route::Radarr(_, _) => RadarrContextClueProvider::get_context_clues(app),
+      Route::Sonarr(_, _) => SonarrContextClueProvider::get_context_clues(app),
+      Route::Lidarr(_, _) => LidarrContextClueProvider::get_context_clues(app),
+      _ => None,
+    }
+  }
+}
+
+pub static SERVARR_CONTEXT_CLUES: [ContextClue; 10] = [
+  (DEFAULT_KEYBINDINGS.up, "scroll up"),
+  (DEFAULT_KEYBINDINGS.down, "scroll down"),
+  (DEFAULT_KEYBINDINGS.left, "previous tab"),
+  (DEFAULT_KEYBINDINGS.right, "next tab"),
+  (DEFAULT_KEYBINDINGS.pg_up, DEFAULT_KEYBINDINGS.pg_up.desc),
+  (
+    DEFAULT_KEYBINDINGS.pg_down,
+    DEFAULT_KEYBINDINGS.pg_down.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.next_servarr,
+    DEFAULT_KEYBINDINGS.next_servarr.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.previous_servarr,
+    DEFAULT_KEYBINDINGS.previous_servarr.desc,
+  ),
   (DEFAULT_KEYBINDINGS.quit, DEFAULT_KEYBINDINGS.quit.desc),
+  (DEFAULT_KEYBINDINGS.help, DEFAULT_KEYBINDINGS.help.desc),
 ];
 
 pub static BARE_POPUP_CONTEXT_CLUES: [ContextClue; 1] =
   [(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)];
+
+pub static BLOCKLIST_CONTEXT_CLUES: [ContextClue; 5] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.clear, "clear blocklist"),
+];
+
+pub static CONFIRMATION_PROMPT_CONTEXT_CLUES: [ContextClue; 2] = [
+  (DEFAULT_KEYBINDINGS.confirm, "submit"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel"),
+];
+
+pub static DOWNLOADS_CONTEXT_CLUES: [ContextClue; 3] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.update, "update downloads"),
+];
+
+pub static ROOT_FOLDERS_CONTEXT_CLUES: [ContextClue; 3] = [
+  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+];
+
+pub static INDEXERS_CONTEXT_CLUES: [ContextClue; 6] = [
+  (DEFAULT_KEYBINDINGS.submit, "edit indexer"),
+  (
+    DEFAULT_KEYBINDINGS.settings,
+    DEFAULT_KEYBINDINGS.settings.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.test, "test indexer"),
+  (DEFAULT_KEYBINDINGS.test_all, "test all indexers"),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+];
+
+pub static HISTORY_CONTEXT_CLUES: [ContextClue; 6] = [
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
+];
+
+pub static SYSTEM_CONTEXT_CLUES: [ContextClue; 5] = [
+  (DEFAULT_KEYBINDINGS.tasks, "open tasks"),
+  (DEFAULT_KEYBINDINGS.events, "open events"),
+  (DEFAULT_KEYBINDINGS.logs, "open logs"),
+  (DEFAULT_KEYBINDINGS.update, "open updates"),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+];
+
+pub static SYSTEM_TASKS_CONTEXT_CLUES: [ContextClue; 2] = [
+  (DEFAULT_KEYBINDINGS.submit, "start task"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];

src/app/context_clues_tests.rs

@@ -1,47 +1,315 @@
 #[cfg(test)]
 mod test {
-  use pretty_assertions::{assert_eq, assert_str_eq};
+  use crate::app::context_clues::{
-
+    BARE_POPUP_CONTEXT_CLUES, BLOCKLIST_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES,
-  use crate::app::context_clues::{BARE_POPUP_CONTEXT_CLUES, SERVARR_CONTEXT_CLUES};
+    ContextClueProvider, DOWNLOADS_CONTEXT_CLUES, HISTORY_CONTEXT_CLUES, INDEXERS_CONTEXT_CLUES,
-  use crate::app::{context_clues::build_context_clue_string, key_binding::DEFAULT_KEYBINDINGS};
+    ROOT_FOLDERS_CONTEXT_CLUES, SERVARR_CONTEXT_CLUES, SYSTEM_CONTEXT_CLUES,
-
+    SYSTEM_TASKS_CONTEXT_CLUES, ServarrContextClueProvider,
-  #[test]
+  };
-  fn test_build_context_clue_string() {
+  use crate::app::{App, key_binding::DEFAULT_KEYBINDINGS};
-    let test_context_clues_array = [
+  use crate::models::servarr_data::ActiveKeybindingBlock;
-      (DEFAULT_KEYBINDINGS.add, "add"),
+  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
-      (DEFAULT_KEYBINDINGS.delete, "delete"),
+  use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
-    ];
-
-    assert_str_eq!(
-      build_context_clue_string(&test_context_clues_array),
-      "<a> add | <del> delete"
-    );
-  }
 
   #[test]
   fn test_servarr_context_clues() {
     let mut servarr_context_clues_iter = SERVARR_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = servarr_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      servarr_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.tab);
+      &(DEFAULT_KEYBINDINGS.up, "scroll up")
-    assert_str_eq!(*description, "change servarr");
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = servarr_context_clues_iter.next().unwrap();
+      servarr_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.down, "scroll down")
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.quit);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.quit.desc);
+    assert_some_eq_x!(
-    assert_eq!(servarr_context_clues_iter.next(), None);
+      servarr_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.left, "previous tab")
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.right, "next tab")
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.pg_up, DEFAULT_KEYBINDINGS.pg_up.desc)
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.pg_down,
+        DEFAULT_KEYBINDINGS.pg_down.desc
+      )
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.next_servarr,
+        DEFAULT_KEYBINDINGS.next_servarr.desc
+      )
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.previous_servarr,
+        DEFAULT_KEYBINDINGS.previous_servarr.desc
+      )
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.quit, DEFAULT_KEYBINDINGS.quit.desc)
+    );
+    assert_some_eq_x!(
+      servarr_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.help, DEFAULT_KEYBINDINGS.help.desc)
+    );
+    assert_none!(servarr_context_clues_iter.next());
   }
 
   #[test]
   fn test_bare_popup_context_clues() {
     let mut bare_popup_context_clues_iter = BARE_POPUP_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = bare_popup_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
+      bare_popup_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(bare_popup_context_clues_iter.next());
+  }
 
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+  #[test]
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
+  fn test_downloads_context_clues() {
-    assert_eq!(bare_popup_context_clues_iter.next(), None);
+    let mut downloads_context_clues_iter = DOWNLOADS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      downloads_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      downloads_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      downloads_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, "update downloads")
+    );
+    assert_none!(downloads_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_blocklist_context_clues() {
+    let mut blocklist_context_clues_iter = BLOCKLIST_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      blocklist_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      blocklist_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      blocklist_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      blocklist_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      blocklist_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.clear, "clear blocklist")
+    );
+    assert_none!(blocklist_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_confirmation_prompt_context_clues() {
+    let mut confirmation_prompt_context_clues_iter = CONFIRMATION_PROMPT_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      confirmation_prompt_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.confirm, "submit")
+    );
+    assert_some_eq_x!(
+      confirmation_prompt_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel")
+    );
+    assert_none!(confirmation_prompt_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_root_folders_context_clues() {
+    let mut root_folders_context_clues_iter = ROOT_FOLDERS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      root_folders_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc)
+    );
+    assert_some_eq_x!(
+      root_folders_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      root_folders_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_none!(root_folders_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_indexers_context_clues() {
+    let mut indexers_context_clues_iter = INDEXERS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "edit indexer")
+    );
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.settings,
+        DEFAULT_KEYBINDINGS.settings.desc
+      )
+    );
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.test, "test indexer")
+    );
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.test_all, "test all indexers")
+    );
+    assert_some_eq_x!(
+      indexers_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_none!(indexers_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_history_context_clues() {
+    let mut history_context_clues_iter = HISTORY_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
+    );
+    assert_none!(history_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_system_context_clues() {
+    let mut system_context_clues_iter = SYSTEM_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      system_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.tasks, "open tasks")
+    );
+    assert_some_eq_x!(
+      system_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.events, "open events")
+    );
+    assert_some_eq_x!(
+      system_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.logs, "open logs")
+    );
+    assert_some_eq_x!(
+      system_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, "open updates")
+    );
+    assert_some_eq_x!(
+      system_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_none!(system_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_system_tasks_context_clues() {
+    let mut system_tasks_context_clues_iter = SYSTEM_TASKS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      system_tasks_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "start task")
+    );
+    assert_some_eq_x!(
+      system_tasks_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(system_tasks_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_servarr_context_clue_provider_delegates_to_radarr_provider() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
+
+    let context_clues = ServarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES,);
+  }
+
+  #[test]
+  fn test_servarr_context_clue_provider_delegates_to_sonarr_provider() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveSonarrBlock::SystemTasks.into());
+
+    let context_clues = ServarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES,);
+  }
+
+  #[test]
+  fn test_servarr_context_clue_provider_unsupported_route_returns_none() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveKeybindingBlock::Help.into());
+
+    let context_clues = ServarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_none!(context_clues);
   }
 }

src/app/key_binding.rs

@@ -14,10 +14,16 @@ generate_keybindings! {
   down,
   left,
   right,
+  pg_down,
+  pg_up,
   backspace,
+  next_servarr,
+  previous_servarr,
   clear,
   search,
+  auto_search,
   settings,
+  help,
   filter,
   sort,
   edit,
@@ -25,14 +31,15 @@ generate_keybindings! {
   tasks,
   test,
   test_all,
+  toggle_monitoring,
   refresh,
   update,
   events,
   home,
   end,
-  tab,
   delete,
   submit,
+  confirm,
   quit,
   esc
 }
@@ -40,112 +47,203 @@ generate_keybindings! {
 #[derive(Clone, Copy, Eq, PartialEq, Debug)]
 pub struct KeyBinding {
   pub key: Key,
+  pub alt: Option<Key>,
   pub desc: &'static str,
 }
 
 pub const DEFAULT_KEYBINDINGS: KeyBindings = KeyBindings {
   add: KeyBinding {
     key: Key::Char('a'),
+    alt: None,
     desc: "add",
   },
   up: KeyBinding {
     key: Key::Up,
+    alt: Some(Key::Char('k')),
     desc: "up",
   },
   down: KeyBinding {
     key: Key::Down,
+    alt: Some(Key::Char('j')),
     desc: "down",
   },
   left: KeyBinding {
     key: Key::Left,
+    alt: Some(Key::Char('h')),
     desc: "left",
   },
   right: KeyBinding {
     key: Key::Right,
+    alt: Some(Key::Char('l')),
     desc: "right",
   },
+  pg_down: KeyBinding {
+    key: Key::PgDown,
+    alt: Some(Key::Ctrl('d')),
+    desc: "page down",
+  },
+  pg_up: KeyBinding {
+    key: Key::PgUp,
+    alt: Some(Key::Ctrl('u')),
+    desc: "page up",
+  },
   backspace: KeyBinding {
     key: Key::Backspace,
+    alt: Some(Key::Ctrl('h')),
     desc: "backspace",
   },
+  next_servarr: KeyBinding {
+    key: Key::Tab,
+    alt: None,
+    desc: "next servarr",
+  },
+  previous_servarr: KeyBinding {
+    key: Key::BackTab,
+    alt: None,
+    desc: "previous servarr",
+  },
   clear: KeyBinding {
     key: Key::Char('c'),
+    alt: None,
     desc: "clear",
   },
+  auto_search: KeyBinding {
+    key: Key::Char('S'),
+    alt: None,
+    desc: "auto search",
+  },
   search: KeyBinding {
     key: Key::Char('s'),
+    alt: None,
     desc: "search",
   },
   settings: KeyBinding {
-    key: Key::Char('s'),
+    key: Key::Char('S'),
+    alt: None,
     desc: "settings",
   },
+  help: KeyBinding {
+    key: Key::Char('?'),
+    alt: None,
+    desc: "show/hide keybindings",
+  },
   filter: KeyBinding {
     key: Key::Char('f'),
+    alt: None,
     desc: "filter",
   },
   sort: KeyBinding {
     key: Key::Char('o'),
+    alt: None,
     desc: "sort",
   },
   edit: KeyBinding {
     key: Key::Char('e'),
+    alt: None,
     desc: "edit",
   },
   events: KeyBinding {
     key: Key::Char('e'),
+    alt: None,
     desc: "events",
   },
   logs: KeyBinding {
-    key: Key::Char('l'),
+    key: Key::Char('L'),
+    alt: None,
     desc: "logs",
   },
   tasks: KeyBinding {
     key: Key::Char('t'),
+    alt: None,
     desc: "tasks",
   },
   test: KeyBinding {
     key: Key::Char('t'),
+    alt: None,
     desc: "test",
   },
   test_all: KeyBinding {
     key: Key::Char('T'),
+    alt: None,
     desc: "test all",
   },
+  toggle_monitoring: KeyBinding {
+    key: Key::Char('m'),
+    alt: None,
+    desc: "toggle monitoring",
+  },
   refresh: KeyBinding {
     key: Key::Ctrl('r'),
+    alt: None,
     desc: "refresh",
   },
   update: KeyBinding {
     key: Key::Char('u'),
+    alt: None,
     desc: "update",
   },
   home: KeyBinding {
     key: Key::Home,
+    alt: None,
     desc: "home",
   },
   end: KeyBinding {
     key: Key::End,
+    alt: None,
     desc: "end",
   },
-  tab: KeyBinding {
-    key: Key::Tab,
-    desc: "tab",
-  },
   delete: KeyBinding {
     key: Key::Delete,
+    alt: None,
     desc: "delete",
   },
   submit: KeyBinding {
     key: Key::Enter,
+    alt: None,
+    desc: "submit",
+  },
+  confirm: KeyBinding {
+    key: Key::Ctrl('s'),
+    alt: None,
     desc: "submit",
   },
   quit: KeyBinding {
     key: Key::Char('q'),
+    alt: None,
     desc: "quit",
   },
   esc: KeyBinding {
     key: Key::Esc,
+    alt: None,
     desc: "close",
   },
 };
+
+#[macro_export]
+macro_rules! matches_key {
+  ($binding:ident, $key:expr) => {
+    $crate::app::key_binding::DEFAULT_KEYBINDINGS.$binding.key == $key
+      || ($crate::app::key_binding::DEFAULT_KEYBINDINGS
+        .$binding
+        .alt
+        .is_some()
+        && $crate::app::key_binding::DEFAULT_KEYBINDINGS
+          .$binding
+          .alt
+          .unwrap()
+          == $key)
+  };
+  ($binding:ident, $key:expr, $ignore_special_keys:expr) => {
+    $crate::app::key_binding::DEFAULT_KEYBINDINGS.$binding.key == $key
+      || !$ignore_special_keys
+        && ($crate::app::key_binding::DEFAULT_KEYBINDINGS
+          .$binding
+          .alt
+          .is_some()
+          && $crate::app::key_binding::DEFAULT_KEYBINDINGS
+            .$binding
+            .alt
+            .unwrap()
+            == $key)
+  };
+}

src/app/key_binding_tests.rs

@@ -3,42 +3,90 @@ mod test {
   use pretty_assertions::{assert_eq, assert_str_eq};
   use rstest::rstest;
 
-  use crate::app::key_binding::{KeyBinding, DEFAULT_KEYBINDINGS};
+  use crate::app::key_binding::{DEFAULT_KEYBINDINGS, KeyBinding};
   use crate::event::Key;
+  use crate::matches_key;
 
   #[rstest]
-  #[case(DEFAULT_KEYBINDINGS.add, Key::Char('a'), "add")]
+  #[case(DEFAULT_KEYBINDINGS.add, Key::Char('a'), None, "add")]
-  #[case(DEFAULT_KEYBINDINGS.up, Key::Up, "up")]
+  #[case(DEFAULT_KEYBINDINGS.up, Key::Up, Some(Key::Char('k')), "up")]
-  #[case(DEFAULT_KEYBINDINGS.down, Key::Down, "down")]
+  #[case(DEFAULT_KEYBINDINGS.down, Key::Down, Some(Key::Char('j')), "down")]
-  #[case(DEFAULT_KEYBINDINGS.left, Key::Left, "left")]
+  #[case(DEFAULT_KEYBINDINGS.left, Key::Left, Some(Key::Char('h')), "left")]
-  #[case(DEFAULT_KEYBINDINGS.right, Key::Right, "right")]
+  #[case(DEFAULT_KEYBINDINGS.right, Key::Right, Some(Key::Char('l')), "right")]
-  #[case(DEFAULT_KEYBINDINGS.backspace, Key::Backspace, "backspace")]
+  #[case(DEFAULT_KEYBINDINGS.pg_down, Key::PgDown, Some(Key::Ctrl('d')), "page down")]
-  #[case(DEFAULT_KEYBINDINGS.clear, Key::Char('c'), "clear")]
+  #[case(DEFAULT_KEYBINDINGS.pg_up, Key::PgUp, Some(Key::Ctrl('u')), "page up")]
-  #[case(DEFAULT_KEYBINDINGS.search, Key::Char('s'), "search")]
+  #[case(DEFAULT_KEYBINDINGS.backspace, Key::Backspace, Some(Key::Ctrl('h')), "backspace")]
-  #[case(DEFAULT_KEYBINDINGS.settings, Key::Char('s'), "settings")]
+  #[case(DEFAULT_KEYBINDINGS.next_servarr, Key::Tab, None, "next servarr")]
-  #[case(DEFAULT_KEYBINDINGS.filter, Key::Char('f'), "filter")]
+  #[case(DEFAULT_KEYBINDINGS.previous_servarr, Key::BackTab, None, "previous servarr")]
-  #[case(DEFAULT_KEYBINDINGS.sort, Key::Char('o'), "sort")]
+  #[case(DEFAULT_KEYBINDINGS.clear, Key::Char('c'), None, "clear")]
-  #[case(DEFAULT_KEYBINDINGS.edit, Key::Char('e'), "edit")]
+  #[case(DEFAULT_KEYBINDINGS.auto_search, Key::Char('S'), None, "auto search")]
-  #[case(DEFAULT_KEYBINDINGS.events, Key::Char('e'), "events")]
+  #[case(DEFAULT_KEYBINDINGS.search, Key::Char('s'), None, "search")]
-  #[case(DEFAULT_KEYBINDINGS.logs, Key::Char('l'), "logs")]
+  #[case(DEFAULT_KEYBINDINGS.settings, Key::Char('S'), None, "settings")]
-  #[case(DEFAULT_KEYBINDINGS.tasks, Key::Char('t'), "tasks")]
+  #[case(DEFAULT_KEYBINDINGS.help, Key::Char('?'), None, "show/hide keybindings")]
-  #[case(DEFAULT_KEYBINDINGS.test, Key::Char('t'), "test")]
+  #[case(DEFAULT_KEYBINDINGS.filter, Key::Char('f'), None, "filter")]
-  #[case(DEFAULT_KEYBINDINGS.test_all, Key::Char('T'), "test all")]
+  #[case(DEFAULT_KEYBINDINGS.sort, Key::Char('o'), None, "sort")]
-  #[case(DEFAULT_KEYBINDINGS.refresh, Key::Ctrl('r'), "refresh")]
+  #[case(DEFAULT_KEYBINDINGS.edit, Key::Char('e'), None, "edit")]
-  #[case(DEFAULT_KEYBINDINGS.update, Key::Char('u'), "update")]
+  #[case(DEFAULT_KEYBINDINGS.events, Key::Char('e'), None, "events")]
-  #[case(DEFAULT_KEYBINDINGS.home, Key::Home, "home")]
+  #[case(DEFAULT_KEYBINDINGS.logs, Key::Char('L'), None, "logs")]
-  #[case(DEFAULT_KEYBINDINGS.end, Key::End, "end")]
+  #[case(DEFAULT_KEYBINDINGS.tasks, Key::Char('t'), None, "tasks")]
-  #[case(DEFAULT_KEYBINDINGS.tab, Key::Tab, "tab")]
+  #[case(DEFAULT_KEYBINDINGS.test, Key::Char('t'), None, "test")]
-  #[case(DEFAULT_KEYBINDINGS.delete, Key::Delete, "delete")]
+  #[case(DEFAULT_KEYBINDINGS.test_all, Key::Char('T'), None, "test all")]
-  #[case(DEFAULT_KEYBINDINGS.submit, Key::Enter, "submit")]
+  #[case(DEFAULT_KEYBINDINGS.toggle_monitoring, Key::Char('m'), None, "toggle monitoring")]
-  #[case(DEFAULT_KEYBINDINGS.quit, Key::Char('q'), "quit")]
+  #[case(DEFAULT_KEYBINDINGS.refresh, Key::Ctrl('r'), None, "refresh")]
-  #[case(DEFAULT_KEYBINDINGS.esc, Key::Esc, "close")]
+  #[case(DEFAULT_KEYBINDINGS.update, Key::Char('u'), None, "update")]
+  #[case(DEFAULT_KEYBINDINGS.home, Key::Home, None, "home")]
+  #[case(DEFAULT_KEYBINDINGS.end, Key::End, None, "end")]
+  #[case(DEFAULT_KEYBINDINGS.delete, Key::Delete, None, "delete")]
+  #[case(DEFAULT_KEYBINDINGS.submit, Key::Enter, None, "submit")]
+  #[case(DEFAULT_KEYBINDINGS.confirm, Key::Ctrl('s'), None, "submit")]
+  #[case(DEFAULT_KEYBINDINGS.quit, Key::Char('q'), None, "quit")]
+  #[case(DEFAULT_KEYBINDINGS.esc, Key::Esc, None, "close")]
   fn test_default_key_bindings_and_descriptions(
     #[case] key_binding: KeyBinding,
     #[case] expected_key: Key,
+    #[case] expected_alt_key: Option<Key>,
     #[case] expected_desc: &str,
   ) {
     assert_eq!(key_binding.key, expected_key);
+    assert_eq!(key_binding.alt, expected_alt_key);
     assert_str_eq!(key_binding.desc, expected_desc);
   }
+
+  #[test]
+  fn test_matches_key_macro() {
+    let key = Key::Char('t');
+
+    assert!(matches_key!(test, key));
+    assert!(!matches_key!(test, Key::Char('T')));
+  }
+
+  #[test]
+  fn test_matches_key_macro_with_alt_keybinding() {
+    let alt_key = Key::Char('k');
+    let key = Key::Up;
+
+    assert!(matches_key!(up, key));
+    assert!(matches_key!(up, alt_key));
+    assert!(!matches_key!(up, Key::Char('t')));
+  }
+
+  #[test]
+  fn test_matches_key_macro_with_alt_keybinding_uses_alt_key_when_ignore_special_keys_is_false() {
+    let alt_key = Key::Char('k');
+    let key = Key::Up;
+
+    assert!(matches_key!(up, key, false));
+    assert!(matches_key!(up, alt_key, false));
+    assert!(!matches_key!(up, Key::Char('t'), false));
+  }
+
+  #[test]
+  fn test_matches_key_macro_with_alt_keybinding_ignores_alt_key_when_ignore_special_keys_is_true() {
+    let alt_key = Key::Char('k');
+    let key = Key::Up;
+
+    assert!(matches_key!(up, key, true));
+    assert!(!matches_key!(up, alt_key, true));
+    assert!(!matches_key!(up, Key::Char('t'), true));
+  }
 }

src/app/lidarr/lidarr_context_clues.rs

@@ -0,0 +1,225 @@
+use crate::app::App;
+use crate::app::context_clues::{
+  BARE_POPUP_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES, ContextClue, ContextClueProvider,
+  SYSTEM_TASKS_CONTEXT_CLUES,
+};
+use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+use crate::models::Route;
+use crate::models::servarr_data::lidarr::lidarr_data::{
+  ADD_ARTIST_BLOCKS, ADD_ROOT_FOLDER_BLOCKS, ALBUM_DETAILS_BLOCKS, ARTIST_DETAILS_BLOCKS,
+  ActiveLidarrBlock, EDIT_ARTIST_BLOCKS, EDIT_INDEXER_BLOCKS, INDEXER_SETTINGS_BLOCKS,
+  TRACK_DETAILS_BLOCKS,
+};
+
+#[cfg(test)]
+#[path = "lidarr_context_clues_tests.rs"]
+mod lidarr_context_clues_tests;
+
+pub static ARTISTS_CONTEXT_CLUES: [ContextClue; 10] = [
+  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.update, "update all"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
+];
+
+pub static ADD_ARTIST_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "edit search"),
+];
+
+pub static ARTIST_DETAILS_CONTEXT_CLUES: [ContextClue; 8] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.edit, "edit artist"),
+  (DEFAULT_KEYBINDINGS.delete, "delete album"),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    "toggle album monitoring",
+  ),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static ARTIST_HISTORY_CONTEXT_CLUES: [ContextClue; 9] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.edit, "edit artist"),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
+];
+
+pub static MANUAL_ARTIST_SEARCH_CONTEXT_CLUES: [ContextClue; 7] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.edit, "edit artist"),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static ALBUM_DETAILS_CONTEXT_CLUES: [ContextClue; 6] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+  (DEFAULT_KEYBINDINGS.submit, "track details"),
+  (DEFAULT_KEYBINDINGS.delete, "delete track"),
+];
+
+pub static ALBUM_HISTORY_CONTEXT_CLUES: [ContextClue; 7] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
+];
+
+pub static MANUAL_ALBUM_SEARCH_CONTEXT_CLUES: [ContextClue; 5] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static TRACK_DETAILS_CONTEXT_CLUES: [ContextClue; 2] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static TRACK_HISTORY_CONTEXT_CLUES: [ContextClue; 6] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
+];
+
+pub(in crate::app) struct LidarrContextClueProvider;
+
+impl ContextClueProvider for LidarrContextClueProvider {
+  fn get_context_clues(app: &mut App<'_>) -> Option<&'static [ContextClue]> {
+    let Route::Lidarr(active_lidarr_block, _context_option) = app.get_current_route() else {
+      panic!("LidarrContextClueProvider::get_context_clues called with non-Lidarr route");
+    };
+
+    match active_lidarr_block {
+      _ if ARTIST_DETAILS_BLOCKS.contains(&active_lidarr_block) => app
+        .data
+        .lidarr_data
+        .artist_info_tabs
+        .get_active_route_contextual_help(),
+      _ if ALBUM_DETAILS_BLOCKS.contains(&active_lidarr_block) => app
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .expect("album_details_modal is empty")
+        .album_details_tabs
+        .get_active_route_contextual_help(),
+      _ if TRACK_DETAILS_BLOCKS.contains(&active_lidarr_block) => app
+        .data
+        .lidarr_data
+        .album_details_modal
+        .as_ref()
+        .expect("album_details_modal is empty")
+        .track_details_modal
+        .as_ref()
+        .expect("track_details_modal is empty")
+        .track_details_tabs
+        .get_active_route_contextual_help(),
+      ActiveLidarrBlock::AddArtistSearchInput
+      | ActiveLidarrBlock::AddArtistEmptySearchResults
+      | ActiveLidarrBlock::TestAllIndexers
+      | ActiveLidarrBlock::SystemLogs
+      | ActiveLidarrBlock::SystemUpdates => Some(&BARE_POPUP_CONTEXT_CLUES),
+      _ if EDIT_ARTIST_BLOCKS.contains(&active_lidarr_block)
+        || EDIT_INDEXER_BLOCKS.contains(&active_lidarr_block)
+        || INDEXER_SETTINGS_BLOCKS.contains(&active_lidarr_block)
+        || ADD_ROOT_FOLDER_BLOCKS.contains(&active_lidarr_block) =>
+      {
+        Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES)
+      }
+      ActiveLidarrBlock::AddArtistPrompt
+      | ActiveLidarrBlock::AddArtistSelectMonitor
+      | ActiveLidarrBlock::AddArtistSelectMonitorNewItems
+      | ActiveLidarrBlock::AddArtistSelectQualityProfile
+      | ActiveLidarrBlock::AddArtistSelectMetadataProfile
+      | ActiveLidarrBlock::AddArtistSelectRootFolder
+      | ActiveLidarrBlock::AddArtistTagsInput
+      | ActiveLidarrBlock::AddArtistAlreadyInLibrary => Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES),
+      _ if ADD_ARTIST_BLOCKS.contains(&active_lidarr_block) => {
+        Some(&ADD_ARTIST_SEARCH_RESULTS_CONTEXT_CLUES)
+      }
+      ActiveLidarrBlock::SystemTasks => Some(&SYSTEM_TASKS_CONTEXT_CLUES),
+      _ => app
+        .data
+        .lidarr_data
+        .main_tabs
+        .get_active_route_contextual_help(),
+    }
+  }
+}

src/app/lidarr/lidarr_context_clues_tests.rs

@@ -0,0 +1,589 @@
+#[cfg(test)]
+mod tests {
+  use crate::app::App;
+  use crate::app::context_clues::{
+    BARE_POPUP_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES, ContextClue, ContextClueProvider,
+    SYSTEM_TASKS_CONTEXT_CLUES,
+  };
+  use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+  use crate::app::lidarr::lidarr_context_clues::{
+    ADD_ARTIST_SEARCH_RESULTS_CONTEXT_CLUES, ALBUM_DETAILS_CONTEXT_CLUES,
+    ALBUM_HISTORY_CONTEXT_CLUES, ARTIST_DETAILS_CONTEXT_CLUES, ARTIST_HISTORY_CONTEXT_CLUES,
+    ARTISTS_CONTEXT_CLUES, LidarrContextClueProvider, MANUAL_ALBUM_SEARCH_CONTEXT_CLUES,
+    MANUAL_ARTIST_SEARCH_CONTEXT_CLUES, TRACK_DETAILS_CONTEXT_CLUES, TRACK_HISTORY_CONTEXT_CLUES,
+  };
+  use crate::models::servarr_data::lidarr::lidarr_data::{
+    ADD_ROOT_FOLDER_BLOCKS, ActiveLidarrBlock, EDIT_ARTIST_BLOCKS, EDIT_INDEXER_BLOCKS,
+    INDEXER_SETTINGS_BLOCKS, LidarrData,
+  };
+  use crate::models::servarr_data::lidarr::modals::{AlbumDetailsModal, TrackDetailsModal};
+  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
+  use rstest::rstest;
+
+  #[test]
+  fn test_artists_context_clues() {
+    let mut artists_context_clues_iter = ARTISTS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
+        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
+      )
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, "update all")
+    );
+    assert_some_eq_x!(
+      artists_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
+    );
+    assert_none!(artists_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_artist_details_context_clues() {
+    let mut artist_details_context_clues_iter = ARTIST_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc,
+      )
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, "edit artist")
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, "delete album")
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
+        "toggle album monitoring",
+      )
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc,
+      )
+    );
+    assert_some_eq_x!(
+      artist_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(artist_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_add_artist_search_results_context_clues() {
+    let mut add_artist_search_results_context_clues_iter =
+      ADD_ARTIST_SEARCH_RESULTS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      add_artist_search_results_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      add_artist_search_results_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "edit search")
+    );
+    assert_none!(add_artist_search_results_context_clues_iter.next());
+  }
+
+  #[test]
+  #[should_panic(
+    expected = "LidarrContextClueProvider::get_context_clues called with non-Lidarr route"
+  )]
+  fn test_lidarr_context_clue_provider_get_context_clues_non_lidarr_route() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveRadarrBlock::default().into());
+
+    LidarrContextClueProvider::get_context_clues(&mut app);
+  }
+
+  #[test]
+  fn test_artist_history_context_clues() {
+    let mut artist_history_context_clues_iter = ARTIST_HISTORY_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, "edit artist")
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      artist_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
+    );
+    assert_none!(artist_history_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_manual_artist_search_context_clues() {
+    let mut manual_artist_search_context_clues_iter = MANUAL_ARTIST_SEARCH_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, "edit artist")
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      manual_artist_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(manual_artist_search_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_album_details_context_clues() {
+    let mut album_details_context_clues_iter = ALBUM_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "track details")
+    );
+    assert_some_eq_x!(
+      album_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, "delete track")
+    );
+    assert_none!(album_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_album_history_context_clues() {
+    let mut album_history_context_clues_iter = ALBUM_HISTORY_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      album_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
+    );
+    assert_none!(album_history_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_manual_album_search_context_clues() {
+    let mut manual_album_search_context_clues_iter = MANUAL_ALBUM_SEARCH_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      manual_album_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_album_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_album_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      manual_album_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      manual_album_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(manual_album_search_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_track_details_context_clues() {
+    let mut track_details_context_clues_iter = TRACK_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      track_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      track_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(track_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_track_history_context_clues() {
+    let mut track_history_context_clues_iter = TRACK_HISTORY_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      track_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
+    );
+    assert_none!(track_history_context_clues_iter.next());
+  }
+
+  #[rstest]
+  #[case(0, ActiveLidarrBlock::ArtistDetails, &ARTIST_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveLidarrBlock::ArtistHistory, &ARTIST_HISTORY_CONTEXT_CLUES)]
+  #[case(2, ActiveLidarrBlock::ManualArtistSearch, &MANUAL_ARTIST_SEARCH_CONTEXT_CLUES)]
+  fn test_lidarr_context_clue_provider_artist_info_tabs(
+    #[case] index: usize,
+    #[case] active_lidarr_block: ActiveLidarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    app.data.lidarr_data = LidarrData::default();
+    app.data.lidarr_data.artist_info_tabs.set_index(index);
+    app.push_navigation_stack(active_lidarr_block.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  #[case(0, ActiveLidarrBlock::AlbumDetails, &ALBUM_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveLidarrBlock::AlbumHistory, &ALBUM_HISTORY_CONTEXT_CLUES)]
+  #[case(2, ActiveLidarrBlock::ManualAlbumSearch, &MANUAL_ALBUM_SEARCH_CONTEXT_CLUES)]
+  fn test_lidarr_context_clue_provider_album_details_tabs(
+    #[case] index: usize,
+    #[case] active_lidarr_block: ActiveLidarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    let mut album_details_modal = AlbumDetailsModal::default();
+    album_details_modal.album_details_tabs.set_index(index);
+    let lidarr_data = LidarrData {
+      album_details_modal: Some(album_details_modal),
+      ..LidarrData::default()
+    };
+    app.data.lidarr_data = lidarr_data;
+    app.push_navigation_stack(active_lidarr_block.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  #[case(0, ActiveLidarrBlock::TrackDetails, &TRACK_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveLidarrBlock::TrackHistory, &TRACK_HISTORY_CONTEXT_CLUES)]
+  fn test_lidarr_context_clue_provider_track_details_tabs(
+    #[case] index: usize,
+    #[case] active_lidarr_block: ActiveLidarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    let mut track_details_modal = TrackDetailsModal::default();
+    track_details_modal.track_details_tabs.set_index(index);
+    let album_details_modal = AlbumDetailsModal {
+      track_details_modal: Some(track_details_modal),
+      ..AlbumDetailsModal::default()
+    };
+    let lidarr_data = LidarrData {
+      album_details_modal: Some(album_details_modal),
+      ..LidarrData::default()
+    };
+    app.data.lidarr_data = lidarr_data;
+    app.push_navigation_stack(active_lidarr_block.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_artists_block() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveLidarrBlock::Artists.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ARTISTS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_artists_sort_prompt_block() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveLidarrBlock::ArtistsSortPrompt.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ARTISTS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_search_artists_block() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveLidarrBlock::SearchArtists.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ARTISTS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_filter_artists_block() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveLidarrBlock::FilterArtists.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ARTISTS_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_lidarr_context_clue_provider_bare_popup_context_clues(
+    #[values(
+      ActiveLidarrBlock::AddArtistSearchInput,
+      ActiveLidarrBlock::AddArtistEmptySearchResults,
+      ActiveLidarrBlock::TestAllIndexers
+    )]
+    active_lidarr_block: ActiveLidarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_lidarr_block.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &BARE_POPUP_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_confirmation_prompt_popup_clues_edit_indexer_blocks() {
+    let mut blocks = EDIT_ARTIST_BLOCKS.to_vec();
+    blocks.extend(ADD_ROOT_FOLDER_BLOCKS);
+    blocks.extend(INDEXER_SETTINGS_BLOCKS);
+    blocks.extend(EDIT_INDEXER_BLOCKS);
+
+    for active_lidarr_block in blocks {
+      let mut app = App::test_default();
+      app.push_navigation_stack(active_lidarr_block.into());
+
+      let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+      assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+    }
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_add_artist_search_results_context_clues() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveLidarrBlock::AddArtistSearchResults.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ADD_ARTIST_SEARCH_RESULTS_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_lidarr_context_clue_provider_confirmation_prompt_context_clues_add_artist_blocks(
+    #[values(
+      ActiveLidarrBlock::AddArtistPrompt,
+      ActiveLidarrBlock::AddArtistSelectMonitor,
+      ActiveLidarrBlock::AddArtistSelectMonitorNewItems,
+      ActiveLidarrBlock::AddArtistSelectQualityProfile,
+      ActiveLidarrBlock::AddArtistSelectMetadataProfile,
+      ActiveLidarrBlock::AddArtistSelectRootFolder,
+      ActiveLidarrBlock::AddArtistTagsInput,
+      ActiveLidarrBlock::AddArtistAlreadyInLibrary
+    )]
+    active_lidarr_block: ActiveLidarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_lidarr_block.into());
+
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_lidarr_context_clue_provider_system_tasks_clues() {
+    let mut app = App::test_default();
+
+    app.push_navigation_stack(ActiveLidarrBlock::SystemTasks.into());
+    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES);
+  }
+}

src/app/lidarr/lidarr_tests.rs

@@ -0,0 +1,783 @@
+#[cfg(test)]
+mod tests {
+  use crate::app::App;
+  use crate::models::lidarr_models::{Album, Artist, LidarrRelease};
+  use crate::models::servarr_data::lidarr::lidarr_data::ActiveLidarrBlock;
+  use crate::models::servarr_data::lidarr::modals::AlbumDetailsModal;
+  use crate::models::servarr_models::Indexer;
+  use crate::network::NetworkEvent;
+  use crate::network::lidarr_network::LidarrEvent;
+  use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::{
+    album, artist, track,
+  };
+  use pretty_assertions::{assert_eq, assert_str_eq};
+  use tokio::sync::mpsc;
+
+  #[tokio::test]
+  async fn test_dispatch_by_lidarr_block_artists() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::Artists)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetQualityProfiles.into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetMetadataProfiles.into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTags.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::ListArtists.into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_lidarr_block_artist_details() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.data.lidarr_data.artists.set_items(vec![artist()]);
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ArtistDetails)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetAlbums(1).into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_blocklist_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.data.lidarr_data.artists.set_items(vec![artist()]);
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::Blocklist)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetBlocklist.into());
+    assert!(!app.data.sonarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_artist_history_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ArtistHistory)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetArtistHistory(1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_manual_artist_search_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ManualArtistSearch)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDiscographyReleases(1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_manual_artist_search_block_discography_releases_non_empty() {
+    let mut app = App::test_default();
+    app
+      .data
+      .lidarr_data
+      .discography_releases
+      .set_items(vec![LidarrRelease::default()]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ManualArtistSearch)
+      .await;
+
+    assert!(!app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_album_details_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+    app.data.lidarr_data.albums.set_items(vec![Album {
+      id: 1,
+      ..Album::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::AlbumDetails)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetTracks(1, 1).into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetTrackFiles(1).into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_album_history_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+    app.data.lidarr_data.albums.set_items(vec![Album {
+      id: 1,
+      ..Album::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::AlbumHistory)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetAlbumHistory(1, 1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_album_history_block_no_op_when_albums_table_is_empty() {
+    let (tx, _) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::AlbumHistory)
+      .await;
+
+    assert!(!app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_manual_album_search_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.artists.set_items(vec![Artist {
+      id: 1,
+      ..Artist::default()
+    }]);
+    app.data.lidarr_data.albums.set_items(vec![Album {
+      id: 1,
+      ..Album::default()
+    }]);
+    app.data.lidarr_data.album_details_modal = Some(AlbumDetailsModal::default());
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ManualAlbumSearch)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetAlbumReleases(1, 1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_manual_album_search_block_is_loading() {
+    let mut app = App {
+      is_loading: true,
+      ..App::test_default()
+    };
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ManualAlbumSearch)
+      .await;
+
+    assert!(app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_manual_album_search_block_album_releases_non_empty() {
+    let mut app = App::test_default();
+    let mut album_details_modal = AlbumDetailsModal::default();
+    album_details_modal
+      .album_releases
+      .set_items(vec![LidarrRelease::default()]);
+    app.data.lidarr_data.album_details_modal = Some(album_details_modal);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::ManualAlbumSearch)
+      .await;
+
+    assert!(!app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_downloads_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::Downloads)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_lidarr_block_add_artist_search_results() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.add_artist_search = Some("test artist".into());
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::AddArtistSearchResults)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::SearchNewArtist("test artist".to_owned()).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_history_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::History)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetHistory(500).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_root_folders_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::RootFolders)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetRootFolders.into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_indexers_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::Indexers)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTags.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetIndexers.into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_all_indexer_settings_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::AllIndexerSettingsPrompt)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetAllIndexerSettings.into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_test_indexer_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.indexers.set_items(vec![Indexer {
+      id: 1,
+      ..Indexer::default()
+    }]);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::TestIndexer)
+      .await;
+
+    assert!(app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::TestIndexer(1).into());
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_test_all_indexers_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::TestAllIndexers)
+      .await;
+
+    assert!(app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::TestAllIndexers.into()
+    );
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_system_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::System)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTasks.into());
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetQueuedEvents.into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetLogs(500).into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_system_updates_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::SystemUpdates)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetUpdates.into());
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_track_details_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default_fully_populated();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::TrackDetails)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetTrackDetails(1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_dispatch_by_track_history_block() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default_fully_populated();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+
+    app
+      .dispatch_by_lidarr_block(&ActiveLidarrBlock::TrackHistory)
+      .await;
+
+    assert!(app.is_loading);
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetTrackHistory(1, 1, 1).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(app.tick_count, 0);
+  }
+
+  #[tokio::test]
+  async fn test_check_for_lidarr_prompt_action_no_prompt_confirm() {
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = false;
+
+    app.check_for_lidarr_prompt_action().await;
+
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert!(!app.should_refresh);
+  }
+
+  #[tokio::test]
+  async fn test_check_for_lidarr_prompt_action() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.data.lidarr_data.prompt_confirm_action = Some(LidarrEvent::GetStatus);
+
+    app.check_for_lidarr_prompt_action().await;
+
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetStatus.into());
+    assert!(app.should_refresh);
+    assert_eq!(app.data.lidarr_data.prompt_confirm_action, None);
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_refresh_metadata() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.is_routing = true;
+
+    app.refresh_lidarr_metadata().await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetQualityProfiles.into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetMetadataProfiles.into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTags.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetRootFolders.into());
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetDiskSpace.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetStatus.into());
+    assert!(app.is_loading);
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_first_render() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.is_first_render = true;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetQualityProfiles.into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetMetadataProfiles.into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTags.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetRootFolders.into());
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetDiskSpace.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetStatus.into());
+    assert!(app.is_loading);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert!(!app.is_first_render);
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_routing() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.is_routing = true;
+    app.should_refresh = true;
+    app.is_first_render = false;
+    app.tick_count = 1;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(!app.data.lidarr_data.prompt_confirm);
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_routing_while_long_request_is_running_should_cancel_request() {
+    let (tx, _) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.is_routing = true;
+    app.should_refresh = false;
+    app.is_first_render = false;
+    app.tick_count = 1;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert!(app.cancellation_token.is_cancelled());
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_should_refresh() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.should_refresh = true;
+    app.is_first_render = false;
+    app.tick_count = 1;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(app.should_refresh);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_should_refresh_does_not_cancel_prompt_requests() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.is_loading = true;
+    app.is_routing = true;
+    app.should_refresh = true;
+    app.is_first_render = false;
+    app.tick_count = 1;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(app.is_loading);
+    assert!(app.should_refresh);
+    assert!(!app.data.lidarr_data.prompt_confirm);
+    assert!(!app.cancellation_token.is_cancelled());
+  }
+
+  #[tokio::test]
+  async fn test_lidarr_on_tick_network_tick_frequency() {
+    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
+    let mut app = App::test_default();
+    app.data.lidarr_data.prompt_confirm = true;
+    app.network_tx = Some(tx);
+    app.tick_count = 2;
+    app.tick_until_poll = 2;
+
+    app.lidarr_on_tick(ActiveLidarrBlock::Downloads).await;
+
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetQualityProfiles.into()
+    );
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetMetadataProfiles.into()
+    );
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetTags.into());
+    assert_eq!(rx.recv().await.unwrap(), LidarrEvent::GetRootFolders.into());
+    assert_eq!(
+      rx.recv().await.unwrap(),
+      LidarrEvent::GetDownloads(500).into()
+    );
+    assert!(app.is_loading);
+  }
+
+  #[tokio::test]
+  async fn test_extract_add_new_artist_search_query() {
+    let app = App::test_default_fully_populated();
+
+    let query = app.extract_add_new_artist_search_query().await;
+
+    assert_str_eq!(query, "Test Artist");
+  }
+
+  #[tokio::test]
+  #[should_panic(expected = "Add artist search is empty")]
+  async fn test_extract_add_new_artist_search_query_panics_when_the_query_is_not_set() {
+    let app = App::test_default();
+
+    app.extract_add_new_artist_search_query().await;
+  }
+
+  #[tokio::test]
+  async fn test_extract_artist_id() {
+    let mut app = App::test_default();
+    app.data.lidarr_data.artists.set_items(vec![artist()]);
+
+    assert_eq!(app.extract_artist_id().await, 1);
+  }
+
+  #[tokio::test]
+  async fn test_extract_album_id() {
+    let mut app = App::test_default();
+    app.data.lidarr_data.albums.set_items(vec![album()]);
+
+    assert_eq!(app.extract_album_id().await, 1);
+  }
+
+  #[tokio::test]
+  async fn test_extract_track_id() {
+    let mut app = App::test_default();
+    let mut album_details_modal = AlbumDetailsModal::default();
+    album_details_modal.tracks.set_items(vec![track()]);
+    app.data.lidarr_data.album_details_modal = Some(album_details_modal);
+
+    assert_eq!(app.extract_track_id().await, 1);
+  }
+
+  #[tokio::test]
+  #[should_panic(expected = "album_details_modal is empty")]
+  async fn test_extract_track_id_panics_when_album_details_modal_is_not_set() {
+    let app = App::test_default();
+
+    app.extract_track_id().await;
+  }
+
+  #[tokio::test]
+  async fn test_extract_lidarr_indexer_id() {
+    let mut app = App::test_default();
+    app.data.lidarr_data.indexers.set_items(vec![Indexer {
+      id: 1,
+      ..Indexer::default()
+    }]);
+
+    assert_eq!(app.extract_lidarr_indexer_id().await, 1);
+  }
+}

src/app/lidarr/mod.rs

@@ -0,0 +1,279 @@
+use super::App;
+use crate::{
+  models::servarr_data::lidarr::lidarr_data::ActiveLidarrBlock,
+  network::lidarr_network::LidarrEvent,
+};
+
+pub mod lidarr_context_clues;
+
+#[cfg(test)]
+#[path = "lidarr_tests.rs"]
+mod lidarr_tests;
+
+impl App<'_> {
+  pub(super) async fn dispatch_by_lidarr_block(&mut self, active_lidarr_block: &ActiveLidarrBlock) {
+    match active_lidarr_block {
+      ActiveLidarrBlock::Artists => {
+        self
+          .dispatch_network_event(LidarrEvent::GetQualityProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetMetadataProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetTags.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::ListArtists.into())
+          .await;
+      }
+      ActiveLidarrBlock::Blocklist => {
+        self
+          .dispatch_network_event(LidarrEvent::GetBlocklist.into())
+          .await;
+      }
+      ActiveLidarrBlock::Downloads => {
+        self
+          .dispatch_network_event(LidarrEvent::GetDownloads(500).into())
+          .await;
+      }
+      ActiveLidarrBlock::ArtistDetails => {
+        self
+          .dispatch_network_event(LidarrEvent::GetAlbums(self.extract_artist_id().await).into())
+          .await;
+      }
+      ActiveLidarrBlock::ArtistHistory => {
+        self
+          .dispatch_network_event(
+            LidarrEvent::GetArtistHistory(self.extract_artist_id().await).into(),
+          )
+          .await;
+      }
+      ActiveLidarrBlock::ManualArtistSearch => {
+        if self.data.lidarr_data.discography_releases.is_empty() {
+          self
+            .dispatch_network_event(
+              LidarrEvent::GetDiscographyReleases(self.extract_artist_id().await).into(),
+            )
+            .await;
+        }
+      }
+      ActiveLidarrBlock::AlbumDetails => {
+        let artist_id = self.extract_artist_id().await;
+        let album_id = self.extract_album_id().await;
+        self
+          .dispatch_network_event(LidarrEvent::GetTracks(artist_id, album_id).into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetTrackFiles(album_id).into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetDownloads(500).into())
+          .await;
+      }
+      ActiveLidarrBlock::AlbumHistory => {
+        if !self.data.lidarr_data.albums.is_empty() {
+          self
+            .dispatch_network_event(
+              LidarrEvent::GetAlbumHistory(
+                self.extract_artist_id().await,
+                self.extract_album_id().await,
+              )
+              .into(),
+            )
+            .await;
+        }
+      }
+      ActiveLidarrBlock::ManualAlbumSearch => {
+        match self.data.lidarr_data.album_details_modal.as_ref() {
+          Some(album_details_modal) if album_details_modal.album_releases.is_empty() => {
+            self
+              .dispatch_network_event(
+                LidarrEvent::GetAlbumReleases(
+                  self.extract_artist_id().await,
+                  self.extract_album_id().await,
+                )
+                .into(),
+              )
+              .await;
+          }
+          _ => (),
+        }
+      }
+      ActiveLidarrBlock::AddArtistSearchResults => {
+        self
+          .dispatch_network_event(
+            LidarrEvent::SearchNewArtist(self.extract_add_new_artist_search_query().await).into(),
+          )
+          .await;
+      }
+      ActiveLidarrBlock::History => {
+        self
+          .dispatch_network_event(LidarrEvent::GetHistory(500).into())
+          .await
+      }
+      ActiveLidarrBlock::RootFolders => {
+        self
+          .dispatch_network_event(LidarrEvent::GetRootFolders.into())
+          .await;
+      }
+      ActiveLidarrBlock::Indexers => {
+        self
+          .dispatch_network_event(LidarrEvent::GetTags.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetIndexers.into())
+          .await;
+      }
+      ActiveLidarrBlock::AllIndexerSettingsPrompt => {
+        self
+          .dispatch_network_event(LidarrEvent::GetAllIndexerSettings.into())
+          .await;
+      }
+      ActiveLidarrBlock::TestIndexer => {
+        self
+          .dispatch_network_event(
+            LidarrEvent::TestIndexer(self.extract_lidarr_indexer_id().await).into(),
+          )
+          .await;
+      }
+      ActiveLidarrBlock::TestAllIndexers => {
+        self
+          .dispatch_network_event(LidarrEvent::TestAllIndexers.into())
+          .await;
+      }
+      ActiveLidarrBlock::System => {
+        self
+          .dispatch_network_event(LidarrEvent::GetTasks.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetQueuedEvents.into())
+          .await;
+        self
+          .dispatch_network_event(LidarrEvent::GetLogs(500).into())
+          .await;
+      }
+      ActiveLidarrBlock::SystemUpdates => {
+        self
+          .dispatch_network_event(LidarrEvent::GetUpdates.into())
+          .await;
+      }
+      ActiveLidarrBlock::TrackDetails => {
+        self
+          .dispatch_network_event(
+            LidarrEvent::GetTrackDetails(self.extract_track_id().await).into(),
+          )
+          .await;
+      }
+      ActiveLidarrBlock::TrackHistory => {
+        let artist_id = self.extract_artist_id().await;
+        let album_id = self.extract_album_id().await;
+        let track_id = self.extract_track_id().await;
+        self
+          .dispatch_network_event(
+            LidarrEvent::GetTrackHistory(artist_id, album_id, track_id).into(),
+          )
+          .await;
+      }
+      _ => (),
+    }
+
+    self.check_for_lidarr_prompt_action().await;
+    self.reset_tick_count();
+  }
+
+  async fn extract_add_new_artist_search_query(&self) -> String {
+    self
+      .data
+      .lidarr_data
+      .add_artist_search
+      .as_ref()
+      .expect("Add artist search is empty")
+      .text
+      .clone()
+  }
+
+  async fn extract_artist_id(&self) -> i64 {
+    self.data.lidarr_data.artists.current_selection().id
+  }
+
+  async fn extract_album_id(&self) -> i64 {
+    self.data.lidarr_data.albums.current_selection().id
+  }
+
+  async fn extract_track_id(&self) -> i64 {
+    self
+      .data
+      .lidarr_data
+      .album_details_modal
+      .as_ref()
+      .expect("album_details_modal is empty")
+      .tracks
+      .current_selection()
+      .id
+  }
+
+  async fn extract_lidarr_indexer_id(&self) -> i64 {
+    self.data.lidarr_data.indexers.current_selection().id
+  }
+
+  async fn check_for_lidarr_prompt_action(&mut self) {
+    if self.data.lidarr_data.prompt_confirm {
+      self.data.lidarr_data.prompt_confirm = false;
+      if let Some(lidarr_event) = self.data.lidarr_data.prompt_confirm_action.take() {
+        self.dispatch_network_event(lidarr_event.into()).await;
+        self.should_refresh = true;
+      }
+    }
+  }
+
+  pub(super) async fn lidarr_on_tick(&mut self, active_lidarr_block: ActiveLidarrBlock) {
+    if self.is_first_render {
+      self.refresh_lidarr_metadata().await;
+      self.dispatch_by_lidarr_block(&active_lidarr_block).await;
+      self.is_first_render = false;
+      return;
+    }
+
+    if self.should_refresh {
+      self.dispatch_by_lidarr_block(&active_lidarr_block).await;
+      self.refresh_lidarr_metadata().await;
+    }
+
+    if self.is_routing {
+      if !self.should_refresh {
+        self.cancellation_token.cancel();
+      } else {
+        self.dispatch_by_lidarr_block(&active_lidarr_block).await;
+      }
+    }
+
+    if self.tick_count.is_multiple_of(self.tick_until_poll) {
+      self.refresh_lidarr_metadata().await;
+    }
+  }
+
+  async fn refresh_lidarr_metadata(&mut self) {
+    self
+      .dispatch_network_event(LidarrEvent::GetQualityProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetMetadataProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetTags.into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetRootFolders.into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetDownloads(500).into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetDiskSpace.into())
+      .await;
+    self
+      .dispatch_network_event(LidarrEvent::GetStatus.into())
+      .await;
+  }
+}

src/app/mod.rs

@@ -1,51 +1,151 @@
-use anyhow::anyhow;
+use anyhow::{Error, Result, anyhow};
+use colored::Colorize;
+use itertools::Itertools;
 use log::{debug, error};
+use regex::Regex;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::{fs, process};
 use tokio::sync::mpsc::Sender;
 use tokio_util::sync::CancellationToken;
+use veil::Redact;
 
-use crate::app::context_clues::{build_context_clue_string, SERVARR_CONTEXT_CLUES};
+use crate::cli::Command;
+use crate::models::servarr_data::Notification;
+use crate::models::servarr_data::lidarr::lidarr_data::{ActiveLidarrBlock, LidarrData};
 use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
+use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
+use crate::models::servarr_models::KeybindingItem;
+use crate::models::stateful_table::StatefulTable;
 use crate::models::{HorizontallyScrollableText, Route, TabRoute, TabState};
 use crate::network::NetworkEvent;
 
 #[cfg(test)]
-#[path = "app_tests.rs"]
 mod app_tests;
 pub mod context_clues;
 pub mod key_binding;
 mod key_binding_tests;
+pub mod lidarr;
 pub mod radarr;
-
+pub mod sonarr;
-const DEFAULT_ROUTE: Route = Route::Radarr(ActiveRadarrBlock::Movies, None);
 
 pub struct App<'a> {
   navigation_stack: Vec<Route>,
   network_tx: Option<Sender<NetworkEvent>>,
-  cancellation_token: CancellationToken,
+  pub cancellation_token: CancellationToken,
+  pub is_first_render: bool,
   pub server_tabs: TabState,
+  pub keymapping_table: Option<StatefulTable<KeybindingItem>>,
   pub error: HorizontallyScrollableText,
+  pub notification: Option<Notification>,
   pub tick_until_poll: u64,
   pub ticks_until_scroll: u64,
   pub tick_count: u64,
+  pub ui_scroll_tick_count: u64,
   pub is_routing: bool,
   pub is_loading: bool,
   pub should_refresh: bool,
-  pub should_ignore_quit_key: bool,
+  pub ignore_special_keys_for_textbox_input: bool,
-  pub config: AppConfig,
+  pub cli_mode: bool,
   pub data: Data<'a>,
 }
 
-impl<'a> App<'a> {
+impl App<'_> {
   pub fn new(
     network_tx: Sender<NetworkEvent>,
     config: AppConfig,
     cancellation_token: CancellationToken,
   ) -> Self {
+    let mut server_tabs = Vec::new();
+
+    if let Some(radarr_configs) = config.radarr {
+      let mut unnamed_idx = 0;
+      let radarr_tabs = radarr_configs.into_iter().map(|radarr_config| {
+        let name = if let Some(name) = radarr_config.name.clone() {
+          name
+        } else {
+          unnamed_idx += 1;
+          format!("Radarr {unnamed_idx}")
+        };
+
+        TabRoute {
+          title: name,
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(radarr_config),
+        }
+      });
+      server_tabs.extend(radarr_tabs);
+    }
+
+    if let Some(sonarr_configs) = config.sonarr {
+      let mut unnamed_idx = 0;
+      let sonarr_tabs = sonarr_configs.into_iter().map(|sonarr_config| {
+        let name = if let Some(name) = sonarr_config.name.clone() {
+          name
+        } else {
+          unnamed_idx += 1;
+          format!("Sonarr {unnamed_idx}")
+        };
+
+        TabRoute {
+          title: name,
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(sonarr_config),
+        }
+      });
+      server_tabs.extend(sonarr_tabs);
+    }
+
+    if let Some(lidarr_configs) = config.lidarr {
+      let mut unnamed_idx = 0;
+      let lidarr_tabs = lidarr_configs.into_iter().map(|lidarr_config| {
+        let name = if let Some(name) = lidarr_config.name.clone() {
+          name
+        } else {
+          unnamed_idx += 1;
+          format!("Lidarr {unnamed_idx}")
+        };
+
+        TabRoute {
+          title: name,
+          route: ActiveLidarrBlock::Artists.into(),
+          contextual_help: None,
+          config: Some(lidarr_config),
+        }
+      });
+      server_tabs.extend(lidarr_tabs);
+    }
+
+    let weight_sorted_tabs = server_tabs
+      .into_iter()
+      .sorted_by(|tab1, tab2| {
+        Ord::cmp(
+          tab1
+            .config
+            .as_ref()
+            .unwrap()
+            .weight
+            .as_ref()
+            .unwrap_or(&1000),
+          tab2
+            .config
+            .as_ref()
+            .unwrap()
+            .weight
+            .as_ref()
+            .unwrap_or(&1000),
+        )
+      })
+      .collect();
+
     App {
       network_tx: Some(network_tx),
-      config,
       cancellation_token,
+      server_tabs: TabState::new(weight_sorted_tabs),
       ..App::default()
     }
   }
@@ -53,13 +153,16 @@ impl<'a> App<'a> {
   pub async fn dispatch_network_event(&mut self, action: NetworkEvent) {
     debug!("Dispatching network event: {action:?}");
 
-    self.is_loading = true;
+    if !self.should_refresh {
-    if let Some(network_tx) = &self.network_tx {
+      self.is_loading = true;
-      if let Err(e) = network_tx.send(action).await {
+    }
-        self.is_loading = false;
+
-        error!("Failed to send event. {e:?}");
+    if let Some(network_tx) = &self.network_tx
-        self.handle_error(anyhow!(e));
+      && let Err(e) = network_tx.send(action).await
-      }
+    {
+      self.is_loading = false;
+      error!("Failed to send event. {e:?}");
+      self.handle_error(anyhow!(e));
     }
   }
 
@@ -67,26 +170,38 @@ impl<'a> App<'a> {
     self.tick_count = 0;
   }
 
-  // Allowing this code for now since we'll eventually be implementing additional Servarr support and we'll need it then
+  pub fn on_ui_scroll_tick(&mut self) {
+    if self.ui_scroll_tick_count == self.ticks_until_scroll {
+      self.ui_scroll_tick_count = 0;
+    } else {
+      self.ui_scroll_tick_count += 1;
+    }
+  }
+
   #[allow(dead_code)]
   pub fn reset(&mut self) {
     self.reset_tick_count();
     self.error = HorizontallyScrollableText::default();
+    self.is_first_render = true;
     self.data = Data::default();
   }
 
-  pub fn handle_error(&mut self, error: anyhow::Error) {
+  pub fn handle_error(&mut self, error: Error) {
     if self.error.text.is_empty() {
       self.error = error.to_string().into();
     }
   }
 
-  pub async fn on_tick(&mut self, is_first_render: bool) {
+  pub async fn on_tick(&mut self) {
-    if self.tick_count % self.tick_until_poll == 0 || self.is_routing || self.should_refresh {
+    if self.tick_count.is_multiple_of(self.tick_until_poll)
-      if let Route::Radarr(active_radarr_block, _) = self.get_current_route() {
+      || self.is_routing
-        self
+      || self.should_refresh
-          .radarr_on_tick(*active_radarr_block, is_first_render)
+    {
-          .await;
+      match self.get_current_route() {
+        Route::Radarr(active_radarr_block, _) => self.radarr_on_tick(active_radarr_block).await,
+        Route::Sonarr(active_sonarr_block, _) => self.sonarr_on_tick(active_sonarr_block).await,
+        Route::Lidarr(active_lidarr_block, _) => self.lidarr_on_tick(active_lidarr_block).await,
+        _ => (),
       }
 
       self.is_routing = false;
@@ -103,13 +218,15 @@ impl<'a> App<'a> {
 
   pub fn pop_navigation_stack(&mut self) {
     self.is_routing = true;
-    if self.navigation_stack.len() > 1 {
+    if !self.navigation_stack.is_empty() {
       self.navigation_stack.pop();
     }
   }
 
   pub fn reset_cancellation_token(&mut self) -> CancellationToken {
     self.cancellation_token = CancellationToken::new();
+    self.should_refresh = true;
+    self.is_loading = false;
 
     self.cancellation_token.clone()
   }
@@ -119,71 +236,399 @@ impl<'a> App<'a> {
     self.push_navigation_stack(route);
   }
 
-  pub fn get_current_route(&self) -> &Route {
+  pub fn get_current_route(&self) -> Route {
-    self.navigation_stack.last().unwrap_or(&DEFAULT_ROUTE)
+    *self.navigation_stack.last().unwrap_or(
+      &self
+        .server_tabs
+        .tabs
+        .first()
+        .expect("At least one server tab must exist")
+        .route,
+    )
   }
 }
 
-impl<'a> Default for App<'a> {
+impl Default for App<'_> {
   fn default() -> Self {
     App {
-      navigation_stack: vec![DEFAULT_ROUTE],
+      navigation_stack: Vec::new(),
       network_tx: None,
       cancellation_token: CancellationToken::new(),
+      keymapping_table: None,
       error: HorizontallyScrollableText::default(),
-      server_tabs: TabState::new(vec![
+      notification: None,
-        TabRoute {
+      is_first_render: true,
-          title: "Radarr",
+      server_tabs: TabState::new(Vec::new()),
-          route: ActiveRadarrBlock::Movies.into(),
-          help: format!(
-            "<↑↓> scroll | ←→ change tab | {}  ",
-            build_context_clue_string(&SERVARR_CONTEXT_CLUES)
-          ),
-          contextual_help: None,
-        },
-        TabRoute {
-          title: "Sonarr",
-          route: Route::Sonarr,
-          help: format!("{}  ", build_context_clue_string(&SERVARR_CONTEXT_CLUES)),
-          contextual_help: None,
-        },
-      ]),
       tick_until_poll: 400,
-      ticks_until_scroll: 4,
+      ticks_until_scroll: 64,
       tick_count: 0,
+      ui_scroll_tick_count: 0,
       is_loading: false,
       is_routing: false,
       should_refresh: false,
-      should_ignore_quit_key: false,
+      ignore_special_keys_for_textbox_input: false,
-      config: AppConfig::default(),
+      cli_mode: false,
       data: Data::default(),
     }
   }
 }
 
+#[cfg(test)]
+impl App<'_> {
+  pub fn test_default() -> Self {
+    App {
+      server_tabs: TabState::new(vec![
+        TabRoute {
+          title: "Radarr".to_owned(),
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Sonarr".to_owned(),
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Lidarr".to_owned(),
+          route: ActiveLidarrBlock::Artists.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+      ]),
+      ..App::default()
+    }
+  }
+
+  pub fn test_default_fully_populated() -> Self {
+    App {
+      data: Data {
+        lidarr_data: LidarrData::test_default_fully_populated(),
+        radarr_data: RadarrData::test_default_fully_populated(),
+        sonarr_data: SonarrData::test_default_fully_populated(),
+      },
+      server_tabs: TabState::new(vec![
+        TabRoute {
+          title: "Radarr".to_owned(),
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Sonarr".to_owned(),
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Lidarr".to_owned(),
+          route: ActiveLidarrBlock::Artists.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+      ]),
+      ..App::default()
+    }
+  }
+}
+
 #[derive(Default)]
 pub struct Data<'a> {
+  pub lidarr_data: LidarrData<'a>,
   pub radarr_data: RadarrData<'a>,
+  pub sonarr_data: SonarrData<'a>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct AppConfig {
-  pub radarr: RadarrConfig,
+  pub theme: Option<String>,
+  pub lidarr: Option<Vec<ServarrConfig>>,
+  pub radarr: Option<Vec<ServarrConfig>>,
+  pub sonarr: Option<Vec<ServarrConfig>>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+impl AppConfig {
-pub struct RadarrConfig {
+  pub fn validate(&self, config_path: &str) {
-  pub host: String,
+    if self.lidarr.is_none() && self.radarr.is_none() && self.sonarr.is_none() {
-  pub port: Option<u16>,
+      log_and_print_error(format!(
-  pub api_token: String,
+        "No Servarrs are configured in the file: {config_path}"
-}
+      ));
+      process::exit(1);
+    }
 
-impl Default for RadarrConfig {
+    if let Some(radarr_configs) = &self.radarr {
-  fn default() -> Self {
+      radarr_configs.iter().for_each(|config| config.validate());
-    RadarrConfig {
+    }
-      host: "localhost".to_string(),
+
-      port: Some(7878),
+    if let Some(sonarr_configs) = &self.sonarr {
-      api_token: "".to_string(),
+      sonarr_configs.iter().for_each(|config| config.validate());
+    }
+
+    if let Some(lidarr_configs) = &self.lidarr {
+      lidarr_configs.iter().for_each(|config| config.validate());
+    }
+  }
+
+  pub fn verify_config_present_for_cli(&self, command: &Command) {
+    let msg = |servarr: &str| {
+      log_and_print_error(format!(
+        "{servarr} configuration missing; Unable to run any {servarr} commands."
+      ))
+    };
+    match command {
+      Command::Radarr(_) if self.radarr.is_none() => {
+        msg("Radarr");
+        process::exit(1);
+      }
+      Command::Sonarr(_) if self.sonarr.is_none() => {
+        msg("Sonarr");
+        process::exit(1);
+      }
+      Command::Lidarr(_) if self.lidarr.is_none() => {
+        msg("Lidarr");
+        process::exit(1);
+      }
+      _ => (),
+    }
+  }
+
+  pub fn post_process_initialization(&mut self) {
+    if let Some(radarr_configs) = self.radarr.as_mut() {
+      for radarr_config in radarr_configs {
+        radarr_config.post_process_initialization();
+      }
+    }
+
+    if let Some(sonarr_configs) = self.sonarr.as_mut() {
+      for sonarr_config in sonarr_configs {
+        sonarr_config.post_process_initialization();
+      }
+    }
+
+    if let Some(lidarr_configs) = self.lidarr.as_mut() {
+      for lidarr_config in lidarr_configs {
+        lidarr_config.post_process_initialization();
+      }
     }
   }
 }
+
+#[derive(Redact, Deserialize, Serialize, Clone, PartialEq, Eq)]
+pub struct ServarrConfig {
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub name: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub host: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_u16_env_var")]
+  pub port: Option<u16>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub uri: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_u16_env_var")]
+  pub weight: Option<u16>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  #[redact]
+  pub api_token: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub api_token_file: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var_bool")]
+  pub ssl: Option<bool>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub ssl_cert_path: Option<String>,
+  #[serde(
+    default,
+    deserialize_with = "deserialize_optional_env_var_header_map",
+    serialize_with = "serialize_header_map"
+  )]
+  pub custom_headers: Option<HeaderMap>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var_string_vec")]
+  pub monitored_storage_paths: Option<Vec<String>>,
+}
+
+impl ServarrConfig {
+  fn validate(&self) {
+    if self.host.is_none() && self.uri.is_none() {
+      log_and_print_error("'host' or 'uri' is required for configuration".to_owned());
+      process::exit(1);
+    }
+
+    if self.api_token_file.is_none() && self.api_token.is_none() {
+      log_and_print_error(
+        "'api_token' or 'api_token_path' is required for configuration".to_owned(),
+      );
+      process::exit(1);
+    }
+  }
+
+  pub fn post_process_initialization(&mut self) {
+    if let Some(api_token_file) = self.api_token_file.as_ref() {
+      if !PathBuf::from(api_token_file).exists() {
+        log_and_print_error(format!(
+          "The specified {api_token_file} API token file does not exist"
+        ));
+        process::exit(1);
+      }
+
+      let api_token = fs::read_to_string(api_token_file)
+        .map_err(|e| anyhow!(e))
+        .unwrap();
+      self.api_token = Some(api_token.trim().to_owned());
+    }
+  }
+}
+
+impl Default for ServarrConfig {
+  fn default() -> Self {
+    ServarrConfig {
+      name: None,
+      host: Some("localhost".to_string()),
+      port: None,
+      uri: None,
+      weight: None,
+      api_token: Some(String::new()),
+      api_token_file: None,
+      ssl_cert_path: None,
+      ssl: None,
+      custom_headers: None,
+      monitored_storage_paths: None,
+    }
+  }
+}
+
+pub fn log_and_print_error(error: String) {
+  error!("{error}");
+  eprintln!("error: {}", error.red());
+}
+
+fn serialize_header_map<S>(headers: &Option<HeaderMap>, serializer: S) -> Result<S::Ok, S::Error>
+where
+  S: serde::Serializer,
+{
+  if let Some(headers) = headers {
+    let mut map = HashMap::new();
+    for (name, value) in headers.iter() {
+      let name_str = name.as_str().to_string();
+      let value_str = value
+        .to_str()
+        .map_err(serde::ser::Error::custom)?
+        .to_string();
+
+      map.insert(name_str, value_str);
+    }
+    map.serialize(serializer)
+  } else {
+    serializer.serialize_none()
+  }
+}
+
+fn deserialize_optional_env_var<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let s: Option<String> = Option::deserialize(deserializer)?;
+  match s {
+    Some(value) => {
+      let interpolated = interpolate_env_vars(&value);
+      Ok(Some(interpolated))
+    }
+    None => Ok(None),
+  }
+}
+
+fn deserialize_optional_env_var_bool<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  #[derive(Deserialize)]
+  #[serde(untagged)]
+  enum StringOrBool {
+    Bool(bool),
+    String(String),
+  }
+
+  match StringOrBool::deserialize(deserializer)? {
+    StringOrBool::Bool(b) => Ok(Some(b)),
+    StringOrBool::String(s) => {
+      let val = interpolate_env_vars(&s)
+        .to_lowercase()
+        .parse()
+        .unwrap_or(false);
+      Ok(Some(val))
+    }
+  }
+}
+
+fn deserialize_optional_env_var_header_map<'de, D>(
+  deserializer: D,
+) -> Result<Option<HeaderMap>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let opt: Option<HashMap<String, String>> = Option::deserialize(deserializer)?;
+  match opt {
+    Some(map) => {
+      let mut header_map = HeaderMap::new();
+      for (k, v) in map.iter() {
+        let name = HeaderName::from_bytes(k.as_bytes()).map_err(serde::de::Error::custom)?;
+        let value_str = interpolate_env_vars(v);
+        let value = HeaderValue::from_str(&value_str).map_err(serde::de::Error::custom)?;
+        header_map.insert(name, value);
+      }
+      Ok(Some(header_map))
+    }
+    None => Ok(None),
+  }
+}
+
+fn deserialize_optional_env_var_string_vec<'de, D>(
+  deserializer: D,
+) -> Result<Option<Vec<String>>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let opt: Option<Vec<String>> = Option::deserialize(deserializer)?;
+  match opt {
+    Some(vec) => Ok(Some(
+      vec
+        .into_iter()
+        .map(|it| interpolate_env_vars(&it))
+        .collect(),
+    )),
+    None => Ok(None),
+  }
+}
+
+fn deserialize_u16_env_var<'de, D>(deserializer: D) -> Result<Option<u16>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let s: Option<String> = Option::deserialize(deserializer)?;
+  match s {
+    Some(value) => {
+      let interpolated = interpolate_env_vars(&value);
+      interpolated
+        .parse::<u16>()
+        .map(Some)
+        .map_err(serde::de::Error::custom)
+    }
+    None => Ok(None),
+  }
+}
+
+fn interpolate_env_vars(s: &str) -> String {
+  let result = s.to_string();
+  let scrubbing_regex = Regex::new(r#"[\s{}!$^()\[\]\\|`'"]+"#).unwrap();
+  let var_regex = Regex::new(r"\$\{(.*?)}").unwrap();
+
+  var_regex
+    .replace_all(s, |caps: &regex::Captures<'_>| {
+      if let Some(mat) = caps.get(1)
+        && let Ok(value) = std::env::var(mat.as_str())
+      {
+        return scrubbing_regex.replace_all(&value, "").to_string();
+      }
+
+      scrubbing_regex.replace_all(&result, "").to_string()
+    })
+    .to_string()
+}

src/app/radarr/mod.rs

@@ -8,7 +8,7 @@ pub mod radarr_context_clues;
 #[path = "radarr_tests.rs"]
 mod radarr_tests;
 
-impl<'a> App<'a> {
+impl App<'_> {
   pub(super) async fn dispatch_by_radarr_block(&mut self, active_radarr_block: &ActiveRadarrBlock) {
     match active_radarr_block {
       ActiveRadarrBlock::Blocklist => {
@@ -17,18 +17,30 @@ impl<'a> App<'a> {
           .await;
       }
       ActiveRadarrBlock::Collections => {
+        self
+          .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
+          .await;
         self
           .dispatch_network_event(RadarrEvent::GetCollections.into())
           .await;
+        self
+          .dispatch_network_event(RadarrEvent::GetMovies.into())
+          .await;
       }
       ActiveRadarrBlock::CollectionDetails => {
+        self
+          .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(RadarrEvent::GetTags.into())
+          .await;
         self.is_loading = true;
         self.populate_movie_collection_table().await;
         self.is_loading = false;
       }
       ActiveRadarrBlock::Downloads => {
         self
-          .dispatch_network_event(RadarrEvent::GetDownloads.into())
+          .dispatch_network_event(RadarrEvent::GetDownloads(500).into())
           .await;
       }
       ActiveRadarrBlock::RootFolders => {
@@ -37,14 +49,28 @@ impl<'a> App<'a> {
           .await;
       }
       ActiveRadarrBlock::Movies => {
+        self
+          .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(RadarrEvent::GetTags.into())
+          .await;
         self
           .dispatch_network_event(RadarrEvent::GetMovies.into())
           .await;
         self
-          .dispatch_network_event(RadarrEvent::GetDownloads.into())
+          .dispatch_network_event(RadarrEvent::GetDownloads(500).into())
+          .await;
+      }
+      ActiveRadarrBlock::History => {
+        self
+          .dispatch_network_event(RadarrEvent::GetHistory(500).into())
           .await;
       }
       ActiveRadarrBlock::Indexers => {
+        self
+          .dispatch_network_event(RadarrEvent::GetTags.into())
+          .await;
         self
           .dispatch_network_event(RadarrEvent::GetIndexers.into())
           .await;
@@ -56,7 +82,9 @@ impl<'a> App<'a> {
       }
       ActiveRadarrBlock::TestIndexer => {
         self
-          .dispatch_network_event(RadarrEvent::TestIndexer(None).into())
+          .dispatch_network_event(
+            RadarrEvent::TestIndexer(self.extract_radarr_indexer_id().await).into(),
+          )
           .await;
       }
       ActiveRadarrBlock::TestAllIndexers => {
@@ -72,7 +100,7 @@ impl<'a> App<'a> {
           .dispatch_network_event(RadarrEvent::GetQueuedEvents.into())
           .await;
         self
-          .dispatch_network_event(RadarrEvent::GetLogs(None).into())
+          .dispatch_network_event(RadarrEvent::GetLogs(500).into())
           .await;
       }
       ActiveRadarrBlock::SystemUpdates => {
@@ -82,17 +110,23 @@ impl<'a> App<'a> {
       }
       ActiveRadarrBlock::AddMovieSearchResults => {
         self
-          .dispatch_network_event(RadarrEvent::SearchNewMovie(None).into())
+          .dispatch_network_event(
+            RadarrEvent::SearchNewMovie(self.extract_movie_search_query().await).into(),
+          )
           .await;
       }
       ActiveRadarrBlock::MovieDetails | ActiveRadarrBlock::FileInfo => {
         self
-          .dispatch_network_event(RadarrEvent::GetMovieDetails(None).into())
+          .dispatch_network_event(
+            RadarrEvent::GetMovieDetails(self.extract_movie_id().await).into(),
+          )
           .await;
       }
       ActiveRadarrBlock::MovieHistory => {
         self
-          .dispatch_network_event(RadarrEvent::GetMovieHistory(None).into())
+          .dispatch_network_event(
+            RadarrEvent::GetMovieHistory(self.extract_movie_id().await).into(),
+          )
           .await;
       }
       ActiveRadarrBlock::Cast | ActiveRadarrBlock::Crew => {
@@ -102,7 +136,9 @@ impl<'a> App<'a> {
               || movie_details_modal.movie_crew.items.is_empty() =>
           {
             self
-              .dispatch_network_event(RadarrEvent::GetMovieCredits(None).into())
+              .dispatch_network_event(
+                RadarrEvent::GetMovieCredits(self.extract_movie_id().await).into(),
+              )
               .await;
           }
           _ => (),
@@ -111,7 +147,7 @@ impl<'a> App<'a> {
       ActiveRadarrBlock::ManualSearch => match self.data.radarr_data.movie_details_modal.as_ref() {
         Some(movie_details_modal) if movie_details_modal.movie_releases.items.is_empty() => {
           self
-            .dispatch_network_event(RadarrEvent::GetReleases(None).into())
+            .dispatch_network_event(RadarrEvent::GetReleases(self.extract_movie_id().await).into())
             .await;
         }
         _ => (),
@@ -119,66 +155,47 @@ impl<'a> App<'a> {
       _ => (),
     }
 
-    self.check_for_prompt_action().await;
+    self.check_for_radarr_prompt_action().await;
     self.reset_tick_count();
   }
 
-  async fn check_for_prompt_action(&mut self) {
+  async fn check_for_radarr_prompt_action(&mut self) {
     if self.data.radarr_data.prompt_confirm {
       self.data.radarr_data.prompt_confirm = false;
-      if let Some(radarr_event) = &self.data.radarr_data.prompt_confirm_action {
+      if let Some(radarr_event) = self.data.radarr_data.prompt_confirm_action.take() {
-        self
+        self.dispatch_network_event(radarr_event.into()).await;
-          .dispatch_network_event(radarr_event.clone().into())
-          .await;
         self.should_refresh = true;
-        self.data.radarr_data.prompt_confirm_action = None;
       }
     }
   }
 
-  pub(super) async fn radarr_on_tick(
+  pub(super) async fn radarr_on_tick(&mut self, active_radarr_block: ActiveRadarrBlock) {
-    &mut self,
+    if self.is_first_render {
-    active_radarr_block: ActiveRadarrBlock,
+      self.refresh_radarr_metadata().await;
-    is_first_render: bool,
-  ) {
-    if is_first_render {
-      self
-        .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
-        .await;
-      self
-        .dispatch_network_event(RadarrEvent::GetTags.into())
-        .await;
-      self
-        .dispatch_network_event(RadarrEvent::GetRootFolders.into())
-        .await;
-      self
-        .dispatch_network_event(RadarrEvent::GetOverview.into())
-        .await;
-      self
-        .dispatch_network_event(RadarrEvent::GetStatus.into())
-        .await;
       self.dispatch_by_radarr_block(&active_radarr_block).await;
+      self.is_first_render = false;
+      return;
     }
 
     if self.should_refresh {
       self.dispatch_by_radarr_block(&active_radarr_block).await;
+      self.refresh_radarr_metadata().await;
     }
 
     if self.is_routing {
-      if self.is_loading && !self.should_refresh {
+      if !self.should_refresh {
         self.cancellation_token.cancel();
+      } else {
+        self.dispatch_by_radarr_block(&active_radarr_block).await;
       }
-
-      self.dispatch_by_radarr_block(&active_radarr_block).await;
-      self.refresh_metadata().await;
     }
 
-    if self.tick_count % self.tick_until_poll == 0 {
+    if self.tick_count.is_multiple_of(self.tick_until_poll) {
-      self.refresh_metadata().await;
+      self.refresh_radarr_metadata().await;
     }
   }
 
-  async fn refresh_metadata(&mut self) {
+  async fn refresh_radarr_metadata(&mut self) {
     self
       .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
       .await;
@@ -189,7 +206,13 @@ impl<'a> App<'a> {
       .dispatch_network_event(RadarrEvent::GetRootFolders.into())
       .await;
     self
-      .dispatch_network_event(RadarrEvent::GetDownloads.into())
+      .dispatch_network_event(RadarrEvent::GetDownloads(500).into())
+      .await;
+    self
+      .dispatch_network_event(RadarrEvent::GetDiskSpace.into())
+      .await;
+    self
+      .dispatch_network_event(RadarrEvent::GetStatus.into())
       .await;
   }
 
@@ -208,4 +231,23 @@ impl<'a> App<'a> {
       .collection_movies
       .set_items(collection_movies);
   }
+
+  async fn extract_movie_id(&self) -> i64 {
+    self.data.radarr_data.movies.current_selection().id
+  }
+
+  async fn extract_movie_search_query(&self) -> String {
+    self
+      .data
+      .radarr_data
+      .add_movie_search
+      .as_ref()
+      .expect("Add movie search is empty")
+      .text
+      .clone()
+  }
+
+  async fn extract_radarr_indexer_id(&self) -> i64 {
+    self.data.radarr_data.indexers.current_selection().id
+  }
 }

src/app/radarr/radarr_context_clues.rs

@@ -1,13 +1,26 @@
-use crate::app::context_clues::ContextClue;
+use crate::app::App;
+use crate::app::context_clues::{
+  BARE_POPUP_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES, ContextClue, ContextClueProvider,
+  SYSTEM_TASKS_CONTEXT_CLUES,
+};
 use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+use crate::models::Route;
+use crate::models::servarr_data::radarr::radarr_data::{
+  ADD_MOVIE_BLOCKS, ActiveRadarrBlock, EDIT_COLLECTION_BLOCKS, EDIT_INDEXER_BLOCKS,
+  EDIT_MOVIE_BLOCKS, INDEXER_SETTINGS_BLOCKS, MOVIE_DETAILS_BLOCKS,
+};
 
 #[cfg(test)]
 #[path = "radarr_context_clues_tests.rs"]
 mod radarr_context_clues_tests;
 
-pub static LIBRARY_CONTEXT_CLUES: [ContextClue; 10] = [
+pub static LIBRARY_CONTEXT_CLUES: [ContextClue; 11] = [
   (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
   (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
   (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
   (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
@@ -35,60 +48,6 @@ pub static COLLECTIONS_CONTEXT_CLUES: [ContextClue; 8] = [
   (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
 ];
 
-pub static DOWNLOADS_CONTEXT_CLUES: [ContextClue; 2] = [
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-];
-
-pub static BLOCKLIST_CONTEXT_CLUES: [ContextClue; 5] = [
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
-  (DEFAULT_KEYBINDINGS.submit, "details"),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (DEFAULT_KEYBINDINGS.clear, "clear blocklist"),
-];
-
-pub static ROOT_FOLDERS_CONTEXT_CLUES: [ContextClue; 3] = [
-  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
-pub static INDEXERS_CONTEXT_CLUES: [ContextClue; 6] = [
-  (DEFAULT_KEYBINDINGS.submit, "edit indexer"),
-  (
-    DEFAULT_KEYBINDINGS.settings,
-    DEFAULT_KEYBINDINGS.settings.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (DEFAULT_KEYBINDINGS.test, "test indexer"),
-  (DEFAULT_KEYBINDINGS.test_all, "test all indexers"),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
-pub static SYSTEM_CONTEXT_CLUES: [ContextClue; 5] = [
-  (DEFAULT_KEYBINDINGS.tasks, "open tasks"),
-  (DEFAULT_KEYBINDINGS.events, "open events"),
-  (DEFAULT_KEYBINDINGS.logs, "open logs"),
-  (DEFAULT_KEYBINDINGS.update, "open updates"),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
 pub static MOVIE_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
   (
     DEFAULT_KEYBINDINGS.refresh,
@@ -96,11 +55,14 @@ pub static MOVIE_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
   ),
   (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
-  (DEFAULT_KEYBINDINGS.search, "auto search"),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
   (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 
-pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 6] = [
+pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 7] = [
   (
     DEFAULT_KEYBINDINGS.refresh,
     DEFAULT_KEYBINDINGS.refresh.desc,
@@ -108,24 +70,72 @@ pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 6] = [
   (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
   (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
-  (DEFAULT_KEYBINDINGS.search, "auto search"),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
   (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 
-pub static MANUAL_MOVIE_SEARCH_CONTEXTUAL_CONTEXT_CLUES: [ContextClue; 1] =
-  [(DEFAULT_KEYBINDINGS.submit, "details")];
-
 pub static ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
   (DEFAULT_KEYBINDINGS.submit, "details"),
   (DEFAULT_KEYBINDINGS.esc, "edit search"),
 ];
 
-pub static SYSTEM_TASKS_CONTEXT_CLUES: [ContextClue; 2] = [
+pub static COLLECTION_DETAILS_CONTEXT_CLUES: [ContextClue; 3] = [
-  (DEFAULT_KEYBINDINGS.submit, "start task"),
+  (DEFAULT_KEYBINDINGS.submit, "show overview/add movie"),
+  (DEFAULT_KEYBINDINGS.edit, "edit collection"),
   (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 
-pub static COLLECTION_DETAILS_CONTEXT_CLUES: [ContextClue; 2] = [
+pub(in crate::app) struct RadarrContextClueProvider;
-  (DEFAULT_KEYBINDINGS.submit, "show overview/add movie"),
+
-  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+impl ContextClueProvider for RadarrContextClueProvider {
-];
+  fn get_context_clues(app: &mut App<'_>) -> Option<&'static [ContextClue]> {
+    let Route::Radarr(active_radarr_block, context_option) = app.get_current_route() else {
+      panic!("RadarrContextClueProvider::get_context_clues called with non-Radarr route");
+    };
+    match active_radarr_block {
+      _ if MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block) => app
+        .data
+        .radarr_data
+        .movie_info_tabs
+        .get_active_route_contextual_help(),
+      ActiveRadarrBlock::TestAllIndexers
+      | ActiveRadarrBlock::AddMovieSearchInput
+      | ActiveRadarrBlock::AddMovieEmptySearchResults
+      | ActiveRadarrBlock::SystemLogs
+      | ActiveRadarrBlock::SystemUpdates => Some(&BARE_POPUP_CONTEXT_CLUES),
+      _ if context_option.unwrap_or(active_radarr_block)
+        == ActiveRadarrBlock::ViewMovieOverview =>
+      {
+        Some(&BARE_POPUP_CONTEXT_CLUES)
+      }
+      ActiveRadarrBlock::SystemTasks => Some(&SYSTEM_TASKS_CONTEXT_CLUES),
+      _ if EDIT_COLLECTION_BLOCKS.contains(&active_radarr_block)
+        || EDIT_INDEXER_BLOCKS.contains(&active_radarr_block)
+        || INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block)
+        || EDIT_MOVIE_BLOCKS.contains(&active_radarr_block) =>
+      {
+        Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES)
+      }
+      ActiveRadarrBlock::AddMoviePrompt
+      | ActiveRadarrBlock::AddMovieSelectMonitor
+      | ActiveRadarrBlock::AddMovieSelectMinimumAvailability
+      | ActiveRadarrBlock::AddMovieSelectQualityProfile
+      | ActiveRadarrBlock::AddMovieSelectRootFolder
+      | ActiveRadarrBlock::AddMovieTagsInput
+      | ActiveRadarrBlock::SystemTaskStartConfirmPrompt => Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES),
+      _ if ADD_MOVIE_BLOCKS.contains(&active_radarr_block) => {
+        Some(&ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES)
+      }
+      ActiveRadarrBlock::CollectionDetails => Some(&COLLECTION_DETAILS_CONTEXT_CLUES),
+      _ => app
+        .data
+        .radarr_data
+        .main_tabs
+        .get_active_route_contextual_help(),
+    }
+  }
+}

src/app/radarr/radarr_context_clues_tests.rs

@@ -1,281 +1,152 @@
 #[cfg(test)]
 mod tests {
-  use pretty_assertions::{assert_eq, assert_str_eq};
+  use crate::app::App;
-
+  use crate::app::context_clues::{
+    BARE_POPUP_CONTEXT_CLUES, BLOCKLIST_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES,
+    ContextClue, ContextClueProvider, DOWNLOADS_CONTEXT_CLUES, HISTORY_CONTEXT_CLUES,
+    INDEXERS_CONTEXT_CLUES, ROOT_FOLDERS_CONTEXT_CLUES, SYSTEM_CONTEXT_CLUES,
+    SYSTEM_TASKS_CONTEXT_CLUES,
+  };
   use crate::app::key_binding::DEFAULT_KEYBINDINGS;
   use crate::app::radarr::radarr_context_clues::{
-    ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES, BLOCKLIST_CONTEXT_CLUES, COLLECTIONS_CONTEXT_CLUES,
+    ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES, COLLECTION_DETAILS_CONTEXT_CLUES,
-    COLLECTION_DETAILS_CONTEXT_CLUES, DOWNLOADS_CONTEXT_CLUES, INDEXERS_CONTEXT_CLUES,
+    COLLECTIONS_CONTEXT_CLUES, LIBRARY_CONTEXT_CLUES, MANUAL_MOVIE_SEARCH_CONTEXT_CLUES,
-    LIBRARY_CONTEXT_CLUES, MANUAL_MOVIE_SEARCH_CONTEXTUAL_CONTEXT_CLUES,
+    MOVIE_DETAILS_CONTEXT_CLUES, RadarrContextClueProvider,
-    MANUAL_MOVIE_SEARCH_CONTEXT_CLUES, MOVIE_DETAILS_CONTEXT_CLUES, ROOT_FOLDERS_CONTEXT_CLUES,
-    SYSTEM_CONTEXT_CLUES, SYSTEM_TASKS_CONTEXT_CLUES,
   };
+  use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
+  use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
+  use pretty_assertions::assert_eq;
+  use rstest::rstest;
 
   #[test]
   fn test_library_context_clues() {
     let mut library_context_clues_iter = LIBRARY_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      library_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.add);
+      &(DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc)
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.add.desc);
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+      library_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.edit);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.edit.desc);
+    assert_some_eq_x!(
-
+      library_context_clues_iter.next(),
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+      &(
-
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
+        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
+      )
-
+    );
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      library_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+      library_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.search.desc);
+    assert_some_eq_x!(
-
+      library_context_clues_iter.next(),
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.filter);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.filter.desc);
+      library_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+      library_context_clues_iter.next(),
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+      &(
-
+        DEFAULT_KEYBINDINGS.refresh,
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+        DEFAULT_KEYBINDINGS.refresh.desc
-
+      )
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+    );
-    assert_str_eq!(*description, "update all");
+    assert_some_eq_x!(
-
+      library_context_clues_iter.next(),
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.update, "update all")
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, "details");
+      library_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.submit, "details")
-    let (key_binding, description) = library_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+      library_context_clues_iter.next(),
-    assert_str_eq!(*description, "cancel filter");
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
-    assert_eq!(library_context_clues_iter.next(), None);
+    );
+    assert_none!(library_context_clues_iter.next());
   }
 
   #[test]
   fn test_collections_context_clues() {
     let mut collections_context_clues = COLLECTIONS_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+    assert_some_eq_x!(
-
+      collections_context_clues.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.search.desc);
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+      collections_context_clues.next(),
-
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.edit);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.edit.desc);
+    assert_some_eq_x!(
-
+      collections_context_clues.next(),
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
+      collections_context_clues.next(),
-
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.filter);
+      collections_context_clues.next(),
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.filter.desc);
+      &(
-
+        DEFAULT_KEYBINDINGS.refresh,
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+        DEFAULT_KEYBINDINGS.refresh.desc
-
+      )
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+    assert_some_eq_x!(
-
+      collections_context_clues.next(),
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.update, "update all")
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, "update all");
+      collections_context_clues.next(),
-
+      &(DEFAULT_KEYBINDINGS.submit, "details")
-    let (key_binding, description) = collections_context_clues.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+      collections_context_clues.next(),
-    assert_str_eq!(*description, "details");
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
-
+    );
-    let (key_binding, description) = collections_context_clues.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
-    assert_str_eq!(*description, "cancel filter");
     assert_eq!(collections_context_clues.next(), None);
   }
 
-  #[test]
-  fn test_downloads_context_clues() {
-    let mut downloads_context_clues_iter = DOWNLOADS_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = downloads_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
-
-    let (key_binding, description) = downloads_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
-    assert_eq!(downloads_context_clues_iter.next(), None);
-  }
-
-  #[test]
-  fn test_blocklist_context_clues() {
-    let mut blocklist_context_clues_iter = BLOCKLIST_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
-
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
-
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
-    assert_str_eq!(*description, "details");
-
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
-
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.clear);
-    assert_str_eq!(*description, "clear blocklist");
-    assert_eq!(blocklist_context_clues_iter.next(), None);
-  }
-
-  #[test]
-  fn test_root_folders_context_clues() {
-    let mut root_folders_context_clues_iter = ROOT_FOLDERS_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = root_folders_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.add);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.add.desc);
-
-    let (key_binding, description) = root_folders_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
-
-    let (key_binding, description) = root_folders_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
-    assert_eq!(root_folders_context_clues_iter.next(), None);
-  }
-
-  #[test]
-  fn test_indexers_context_clues() {
-    let mut indexers_context_clues_iter = INDEXERS_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
-    assert_str_eq!(*description, "edit indexer");
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.settings);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.settings.desc);
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.test);
-    assert_str_eq!(*description, "test indexer");
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.test_all);
-    assert_str_eq!(*description, "test all indexers");
-
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
-    assert_eq!(indexers_context_clues_iter.next(), None);
-  }
-
-  #[test]
-  fn test_system_context_clues() {
-    let mut system_context_clues_iter = SYSTEM_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.tasks);
-    assert_str_eq!(*description, "open tasks");
-
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.events);
-    assert_str_eq!(*description, "open events");
-
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.logs);
-    assert_str_eq!(*description, "open logs");
-
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
-    assert_str_eq!(*description, "open updates");
-
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
-    assert_eq!(system_context_clues_iter.next(), None);
-  }
-
   #[test]
   fn test_movie_details_context_clues() {
     let mut movie_details_context_clues_iter = MOVIE_DETAILS_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = movie_details_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      movie_details_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+      &(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+        DEFAULT_KEYBINDINGS.refresh,
-
+        DEFAULT_KEYBINDINGS.refresh.desc
-    let (key_binding, description) = movie_details_context_clues_iter.next().unwrap();
+      )
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.update.desc);
+      movie_details_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
-    let (key_binding, description) = movie_details_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.edit);
+      movie_details_context_clues_iter.next(),
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.edit.desc);
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
-
+    );
-    let (key_binding, description) = movie_details_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      movie_details_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
+      &(
-    assert_str_eq!(*description, "auto search");
+        DEFAULT_KEYBINDINGS.auto_search,
-
+        DEFAULT_KEYBINDINGS.auto_search.desc
-    let (key_binding, description) = movie_details_context_clues_iter.next().unwrap();
+      )
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
+      movie_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
     assert_eq!(movie_details_context_clues_iter.next(), None);
   }
 
@@ -283,53 +154,41 @@ mod tests {
   fn test_manual_movie_search_context_clues() {
     let mut manual_movie_search_context_clues_iter = MANUAL_MOVIE_SEARCH_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      manual_movie_search_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+      &(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+        DEFAULT_KEYBINDINGS.refresh,
-
+        DEFAULT_KEYBINDINGS.refresh.desc
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
+      )
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.update.desc);
-
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.edit);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.edit.desc);
-
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
-
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
-    assert_str_eq!(*description, "auto search");
-
-    let (key_binding, description) = manual_movie_search_context_clues_iter.next().unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
-    assert_eq!(manual_movie_search_context_clues_iter.next(), None);
-  }
-
-  #[test]
-  fn test_manual_movie_search_contextual_context_clues() {
-    let mut manual_movie_search_contextual_context_clues_iter =
-      MANUAL_MOVIE_SEARCH_CONTEXTUAL_CONTEXT_CLUES.iter();
-
-    let (key_binding, description) = manual_movie_search_contextual_context_clues_iter
-      .next()
-      .unwrap();
-
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
-    assert_str_eq!(*description, "details");
-    assert_eq!(
-      manual_movie_search_contextual_context_clues_iter.next(),
-      None
     );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
+    );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      manual_movie_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_eq!(manual_movie_search_context_clues_iter.next(), None);
   }
 
   #[test]
@@ -337,15 +196,14 @@ mod tests {
     let mut add_movie_search_results_context_clues_iter =
       ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = add_movie_search_results_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      add_movie_search_results_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+      &(DEFAULT_KEYBINDINGS.submit, "details")
-    assert_str_eq!(*description, "details");
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = add_movie_search_results_context_clues_iter.next().unwrap();
+      add_movie_search_results_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.esc, "edit search")
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    );
-    assert_str_eq!(*description, "edit search");
     assert_eq!(add_movie_search_results_context_clues_iter.next(), None);
   }
 
@@ -353,15 +211,14 @@ mod tests {
   fn test_system_tasks_context_clues() {
     let mut system_tasks_context_clues_iter = SYSTEM_TASKS_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = system_tasks_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      system_tasks_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+      &(DEFAULT_KEYBINDINGS.submit, "start task")
-    assert_str_eq!(*description, "start task");
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = system_tasks_context_clues_iter.next().unwrap();
+      system_tasks_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
     assert_eq!(system_tasks_context_clues_iter.next(), None);
   }
 
@@ -369,15 +226,256 @@ mod tests {
   fn test_collection_details_context_clues() {
     let mut collection_details_context_clues_iter = COLLECTION_DETAILS_CONTEXT_CLUES.iter();
 
-    let (key_binding, description) = collection_details_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      collection_details_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+      &(DEFAULT_KEYBINDINGS.submit, "show overview/add movie")
-    assert_str_eq!(*description, "show overview/add movie");
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = collection_details_context_clues_iter.next().unwrap();
+      collection_details_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.edit, "edit collection")
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
+    assert_some_eq_x!(
+      collection_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
     assert_eq!(collection_details_context_clues_iter.next(), None);
   }
+
+  #[test]
+  #[should_panic(
+    expected = "RadarrContextClueProvider::get_context_clues called with non-Radarr route"
+  )]
+  fn test_radarr_context_clue_provider_get_context_clues_non_radarr_route() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveSonarrBlock::default().into());
+
+    // This should panic because the route is not a Radarr route
+    RadarrContextClueProvider::get_context_clues(&mut app);
+  }
+
+  #[rstest]
+  #[case(ActiveRadarrBlock::TestAllIndexers, None)]
+  #[case(ActiveRadarrBlock::AddMovieSearchInput, None)]
+  #[case(ActiveRadarrBlock::AddMovieEmptySearchResults, None)]
+  #[case(ActiveRadarrBlock::SystemLogs, None)]
+  #[case(ActiveRadarrBlock::SystemUpdates, None)]
+  #[case(ActiveRadarrBlock::ViewMovieOverview, None)]
+  #[case(
+    ActiveRadarrBlock::CollectionDetails,
+    Some(ActiveRadarrBlock::ViewMovieOverview)
+  )]
+  fn test_radarr_context_clue_provider_bare_popup_context_clues(
+    #[case] active_radarr_block: ActiveRadarrBlock,
+    #[case] context_option: Option<ActiveRadarrBlock>,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack((active_radarr_block, context_option).into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &BARE_POPUP_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  #[case(0, ActiveRadarrBlock::MovieDetails, &MOVIE_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveRadarrBlock::MovieHistory, &MOVIE_DETAILS_CONTEXT_CLUES)]
+  #[case(2, ActiveRadarrBlock::FileInfo, &MOVIE_DETAILS_CONTEXT_CLUES)]
+  #[case(3, ActiveRadarrBlock::Cast, &MOVIE_DETAILS_CONTEXT_CLUES)]
+  #[case(4, ActiveRadarrBlock::Crew, &MOVIE_DETAILS_CONTEXT_CLUES)]
+  #[case(5, ActiveRadarrBlock::ManualSearch, &MANUAL_MOVIE_SEARCH_CONTEXT_CLUES)]
+  fn test_radarr_context_clue_provider_movie_details_block_context_clues(
+    #[case] index: usize,
+    #[case] active_radarr_block: ActiveRadarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.data.radarr_data.movie_info_tabs.set_index(index);
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_confirmation_prompt_context_clues(
+    #[values(
+      ActiveRadarrBlock::AddMoviePrompt,
+      ActiveRadarrBlock::AddMovieSelectMonitor,
+      ActiveRadarrBlock::AddMovieSelectMinimumAvailability,
+      ActiveRadarrBlock::AddMovieSelectQualityProfile,
+      ActiveRadarrBlock::AddMovieSelectRootFolder,
+      ActiveRadarrBlock::AddMovieTagsInput,
+      ActiveRadarrBlock::SystemTaskStartConfirmPrompt
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_confirmation_prompt_context_clues_edit_collection_blocks(
+    #[values(
+      ActiveRadarrBlock::EditCollectionPrompt,
+      ActiveRadarrBlock::EditCollectionConfirmPrompt,
+      ActiveRadarrBlock::EditCollectionRootFolderPathInput,
+      ActiveRadarrBlock::EditCollectionSelectMinimumAvailability,
+      ActiveRadarrBlock::EditCollectionSelectQualityProfile,
+      ActiveRadarrBlock::EditCollectionToggleSearchOnAdd,
+      ActiveRadarrBlock::EditCollectionToggleMonitored
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_confirmation_prompt_context_clues_edit_indexer_blocks(
+    #[values(
+      ActiveRadarrBlock::EditIndexerPrompt,
+      ActiveRadarrBlock::EditIndexerConfirmPrompt,
+      ActiveRadarrBlock::EditIndexerApiKeyInput,
+      ActiveRadarrBlock::EditIndexerNameInput,
+      ActiveRadarrBlock::EditIndexerSeedRatioInput,
+      ActiveRadarrBlock::EditIndexerToggleEnableRss,
+      ActiveRadarrBlock::EditIndexerToggleEnableAutomaticSearch,
+      ActiveRadarrBlock::EditIndexerToggleEnableInteractiveSearch,
+      ActiveRadarrBlock::EditIndexerPriorityInput,
+      ActiveRadarrBlock::EditIndexerUrlInput,
+      ActiveRadarrBlock::EditIndexerTagsInput
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_confirmation_prompt_context_clues_indexer_settings_blocks(
+    #[values(
+      ActiveRadarrBlock::AllIndexerSettingsPrompt,
+      ActiveRadarrBlock::IndexerSettingsAvailabilityDelayInput,
+      ActiveRadarrBlock::IndexerSettingsConfirmPrompt,
+      ActiveRadarrBlock::IndexerSettingsMaximumSizeInput,
+      ActiveRadarrBlock::IndexerSettingsMinimumAgeInput,
+      ActiveRadarrBlock::IndexerSettingsRetentionInput,
+      ActiveRadarrBlock::IndexerSettingsRssSyncIntervalInput,
+      ActiveRadarrBlock::IndexerSettingsToggleAllowHardcodedSubs,
+      ActiveRadarrBlock::IndexerSettingsTogglePreferIndexerFlags,
+      ActiveRadarrBlock::IndexerSettingsWhitelistedSubtitleTagsInput
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_confirmation_prompt_context_clues_edit_movie_blocks(
+    #[values(
+      ActiveRadarrBlock::EditMoviePrompt,
+      ActiveRadarrBlock::EditMovieConfirmPrompt,
+      ActiveRadarrBlock::EditMoviePathInput,
+      ActiveRadarrBlock::EditMovieSelectMinimumAvailability,
+      ActiveRadarrBlock::EditMovieSelectQualityProfile,
+      ActiveRadarrBlock::EditMovieTagsInput,
+      ActiveRadarrBlock::EditMovieToggleMonitored
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_radarr_context_clue_provider_add_movie_search_results_context_clues(
+    #[values(
+      ActiveRadarrBlock::AddMovieSearchResults,
+      ActiveRadarrBlock::AddMovieAlreadyInLibrary
+    )]
+    active_radarr_block: ActiveRadarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_radarr_context_clue_provider_collection_details_context_clues() {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.push_navigation_stack(ActiveRadarrBlock::CollectionDetails.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &COLLECTION_DETAILS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_radarr_context_clue_provider_system_tasks_context_clues() {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+
+    app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  #[case(0, ActiveRadarrBlock::Movies, &LIBRARY_CONTEXT_CLUES)]
+  #[case(1, ActiveRadarrBlock::Collections, &COLLECTIONS_CONTEXT_CLUES)]
+  #[case(2, ActiveRadarrBlock::Downloads, &DOWNLOADS_CONTEXT_CLUES)]
+  #[case(3, ActiveRadarrBlock::Blocklist, &BLOCKLIST_CONTEXT_CLUES)]
+  #[case(4, ActiveRadarrBlock::History, &HISTORY_CONTEXT_CLUES)]
+  #[case(5, ActiveRadarrBlock::RootFolders, &ROOT_FOLDERS_CONTEXT_CLUES)]
+  #[case(6, ActiveRadarrBlock::Indexers, &INDEXERS_CONTEXT_CLUES)]
+  #[case(7, ActiveRadarrBlock::System, &SYSTEM_CONTEXT_CLUES)]
+  fn test_radarr_context_clue_provider_radarr_blocks_context_clues(
+    #[case] index: usize,
+    #[case] active_radarr_block: ActiveRadarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    app.data.radarr_data = RadarrData::default();
+    app.data.radarr_data.main_tabs.set_index(index);
+    app.push_navigation_stack(active_radarr_block.into());
+
+    let context_clues = RadarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
 }

src/app/sonarr/mod.rs

@@ -0,0 +1,303 @@
+use crate::{
+  models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock,
+  network::sonarr_network::SonarrEvent,
+};
+
+use super::App;
+
+pub mod sonarr_context_clues;
+
+#[cfg(test)]
+#[path = "sonarr_tests.rs"]
+mod sonarr_tests;
+
+impl App<'_> {
+  pub(super) async fn dispatch_by_sonarr_block(&mut self, active_sonarr_block: &ActiveSonarrBlock) {
+    match active_sonarr_block {
+      ActiveSonarrBlock::Series => {
+        self
+          .dispatch_network_event(SonarrEvent::GetQualityProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetLanguageProfiles.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetTags.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::ListSeries.into())
+          .await;
+      }
+      ActiveSonarrBlock::SeriesDetails => {
+        self
+          .dispatch_network_event(SonarrEvent::ListSeries.into())
+          .await;
+        self.is_loading = true;
+        self.populate_seasons_table().await;
+        self.is_loading = false;
+      }
+      ActiveSonarrBlock::SeriesHistory => {
+        self
+          .dispatch_network_event(
+            SonarrEvent::GetSeriesHistory(self.extract_series_id().await).into(),
+          )
+          .await;
+      }
+      ActiveSonarrBlock::SeasonDetails => {
+        self
+          .dispatch_network_event(SonarrEvent::GetEpisodes(self.extract_series_id().await).into())
+          .await;
+        self
+          .dispatch_network_event(
+            SonarrEvent::GetEpisodeFiles(self.extract_series_id().await).into(),
+          )
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetDownloads(500).into())
+          .await;
+      }
+      ActiveSonarrBlock::SeasonHistory => {
+        if !self.data.sonarr_data.seasons.is_empty() {
+          let (series_id, season_number) = self.extract_series_id_season_number_tuple().await;
+          self
+            .dispatch_network_event(SonarrEvent::GetSeasonHistory(series_id, season_number).into())
+            .await;
+        }
+      }
+      ActiveSonarrBlock::ManualSeasonSearch => {
+        match self.data.sonarr_data.season_details_modal.as_ref() {
+          Some(season_details_modal) if season_details_modal.season_releases.is_empty() => {
+            let (series_id, season_number) = self.extract_series_id_season_number_tuple().await;
+            self
+              .dispatch_network_event(
+                SonarrEvent::GetSeasonReleases(series_id, season_number).into(),
+              )
+              .await;
+          }
+          _ => (),
+        }
+      }
+      ActiveSonarrBlock::EpisodeDetails | ActiveSonarrBlock::EpisodeFile => {
+        self
+          .dispatch_network_event(
+            SonarrEvent::GetEpisodeDetails(self.extract_episode_id().await).into(),
+          )
+          .await;
+      }
+      ActiveSonarrBlock::EpisodeHistory => {
+        self
+          .dispatch_network_event(
+            SonarrEvent::GetEpisodeHistory(self.extract_episode_id().await).into(),
+          )
+          .await;
+      }
+      ActiveSonarrBlock::ManualEpisodeSearch => {
+        if let Some(season_details_modal) = self.data.sonarr_data.season_details_modal.as_ref()
+          && let Some(episode_details_modal) = season_details_modal.episode_details_modal.as_ref()
+          && episode_details_modal.episode_releases.is_empty()
+        {
+          self
+            .dispatch_network_event(
+              SonarrEvent::GetEpisodeReleases(self.extract_episode_id().await).into(),
+            )
+            .await;
+        }
+      }
+      ActiveSonarrBlock::Downloads => {
+        self
+          .dispatch_network_event(SonarrEvent::GetDownloads(500).into())
+          .await;
+      }
+      ActiveSonarrBlock::Blocklist => {
+        self
+          .dispatch_network_event(SonarrEvent::ListSeries.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetBlocklist.into())
+          .await;
+      }
+      ActiveSonarrBlock::History => {
+        self
+          .dispatch_network_event(SonarrEvent::GetHistory(500).into())
+          .await;
+      }
+      ActiveSonarrBlock::RootFolders => {
+        self
+          .dispatch_network_event(SonarrEvent::GetRootFolders.into())
+          .await;
+      }
+      ActiveSonarrBlock::Indexers => {
+        self
+          .dispatch_network_event(SonarrEvent::GetTags.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetIndexers.into())
+          .await;
+      }
+      ActiveSonarrBlock::AllIndexerSettingsPrompt => {
+        self
+          .dispatch_network_event(SonarrEvent::GetAllIndexerSettings.into())
+          .await;
+      }
+      ActiveSonarrBlock::TestIndexer => {
+        self
+          .dispatch_network_event(
+            SonarrEvent::TestIndexer(self.extract_sonarr_indexer_id().await).into(),
+          )
+          .await;
+      }
+      ActiveSonarrBlock::TestAllIndexers => {
+        self
+          .dispatch_network_event(SonarrEvent::TestAllIndexers.into())
+          .await;
+      }
+      ActiveSonarrBlock::System => {
+        self
+          .dispatch_network_event(SonarrEvent::GetTasks.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetQueuedEvents.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetLogs(500).into())
+          .await;
+      }
+      ActiveSonarrBlock::AddSeriesSearchResults => {
+        self
+          .dispatch_network_event(
+            SonarrEvent::SearchNewSeries(self.extract_add_new_series_search_query().await).into(),
+          )
+          .await;
+      }
+      ActiveSonarrBlock::SystemUpdates => {
+        self
+          .dispatch_network_event(SonarrEvent::GetUpdates.into())
+          .await;
+      }
+      _ => (),
+    }
+
+    self.check_for_sonarr_prompt_action().await;
+    self.reset_tick_count();
+  }
+
+  async fn check_for_sonarr_prompt_action(&mut self) {
+    if self.data.sonarr_data.prompt_confirm {
+      self.data.sonarr_data.prompt_confirm = false;
+      if let Some(sonarr_event) = self.data.sonarr_data.prompt_confirm_action.take() {
+        self.dispatch_network_event(sonarr_event.into()).await;
+        self.should_refresh = true;
+      }
+    }
+  }
+
+  pub(super) async fn sonarr_on_tick(&mut self, active_sonarr_block: ActiveSonarrBlock) {
+    if self.is_first_render {
+      self.refresh_sonarr_metadata().await;
+      self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+      self.is_first_render = false;
+      return;
+    }
+
+    if self.should_refresh {
+      self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+      self.refresh_sonarr_metadata().await;
+    }
+
+    if self.is_routing {
+      if !self.should_refresh {
+        self.cancellation_token.cancel();
+      } else {
+        self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+      }
+    }
+
+    if self.tick_count.is_multiple_of(self.tick_until_poll) {
+      self.refresh_sonarr_metadata().await;
+    }
+  }
+
+  async fn refresh_sonarr_metadata(&mut self) {
+    self
+      .dispatch_network_event(SonarrEvent::GetQualityProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetLanguageProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetTags.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetRootFolders.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetDownloads(500).into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetDiskSpace.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetStatus.into())
+      .await;
+  }
+
+  async fn populate_seasons_table(&mut self) {
+    let seasons = self
+      .data
+      .sonarr_data
+      .series
+      .current_selection()
+      .clone()
+      .seasons
+      .unwrap_or_default()
+      .into_iter()
+      .map(|mut season| {
+        season.title = Some(format!("Season {}", season.season_number));
+        season
+      })
+      .collect();
+    self.data.sonarr_data.seasons.set_items(seasons);
+  }
+
+  async fn extract_episode_id(&self) -> i64 {
+    self
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_ref()
+      .expect("Season details have not been loaded")
+      .episodes
+      .current_selection()
+      .id
+  }
+
+  async fn extract_series_id(&self) -> i64 {
+    self.data.sonarr_data.series.current_selection().id
+  }
+
+  async fn extract_series_id_season_number_tuple(&self) -> (i64, i64) {
+    let series_id = self.data.sonarr_data.series.current_selection().id;
+    let season_number = self
+      .data
+      .sonarr_data
+      .seasons
+      .current_selection()
+      .season_number;
+    (series_id, season_number)
+  }
+
+  async fn extract_add_new_series_search_query(&self) -> String {
+    self
+      .data
+      .sonarr_data
+      .add_series_search
+      .as_ref()
+      .expect("Add series search is empty")
+      .text
+      .clone()
+  }
+
+  async fn extract_sonarr_indexer_id(&self) -> i64 {
+    self.data.sonarr_data.indexers.current_selection().id
+  }
+}

src/app/sonarr/sonarr_context_clues.rs

@@ -0,0 +1,229 @@
+use crate::app::context_clues::{
+  BARE_POPUP_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES, ContextClueProvider,
+  SYSTEM_TASKS_CONTEXT_CLUES,
+};
+use crate::app::{App, context_clues::ContextClue, key_binding::DEFAULT_KEYBINDINGS};
+use crate::models::Route;
+use crate::models::servarr_data::sonarr::sonarr_data::{
+  ADD_SERIES_BLOCKS, ActiveSonarrBlock, EDIT_INDEXER_BLOCKS, EDIT_SERIES_BLOCKS,
+  EPISODE_DETAILS_BLOCKS, INDEXER_SETTINGS_BLOCKS, SEASON_DETAILS_BLOCKS, SERIES_DETAILS_BLOCKS,
+};
+
+#[cfg(test)]
+#[path = "sonarr_context_clues_tests.rs"]
+mod sonarr_context_clues_tests;
+
+pub static ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "edit search"),
+];
+
+pub static SERIES_CONTEXT_CLUES: [ContextClue; 11] = [
+  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
+  (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.update, "update all"),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
+];
+
+pub static SERIES_DETAILS_CONTEXT_CLUES: [ContextClue; 8] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "season details"),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static SERIES_HISTORY_CONTEXT_CLUES: [ContextClue; 9] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
+];
+
+pub static SEASON_DETAILS_CONTEXT_CLUES: [ContextClue; 7] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+  (DEFAULT_KEYBINDINGS.submit, "episode details"),
+  (DEFAULT_KEYBINDINGS.delete, "delete episode"),
+];
+
+pub static SEASON_HISTORY_CONTEXT_CLUES: [ContextClue; 7] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
+];
+
+pub static MANUAL_SEASON_SEARCH_CONTEXT_CLUES: [ContextClue; 5] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static MANUAL_EPISODE_SEARCH_CONTEXT_CLUES: [ContextClue; 5] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static EPISODE_DETAILS_CONTEXT_CLUES: [ContextClue; 3] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub static SELECTABLE_EPISODE_DETAILS_CONTEXT_CLUES: [ContextClue; 4] = [
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
+];
+
+pub(in crate::app) struct SonarrContextClueProvider;
+
+impl ContextClueProvider for SonarrContextClueProvider {
+  fn get_context_clues(app: &mut App<'_>) -> Option<&'static [ContextClue]> {
+    let Route::Sonarr(active_sonarr_block, _) = app.get_current_route() else {
+      panic!("SonarrContextClueProvider::get_context_clues called with non-Sonarr route");
+    };
+    match active_sonarr_block {
+      _ if SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block) => app
+        .data
+        .sonarr_data
+        .series_info_tabs
+        .get_active_route_contextual_help(),
+      _ if SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block) => app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .season_details_tabs
+        .get_active_route_contextual_help(),
+      _ if EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block) => app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_tabs
+        .get_active_route_contextual_help(),
+      ActiveSonarrBlock::TestAllIndexers
+      | ActiveSonarrBlock::AddSeriesSearchInput
+      | ActiveSonarrBlock::AddSeriesEmptySearchResults
+      | ActiveSonarrBlock::SystemLogs
+      | ActiveSonarrBlock::SystemUpdates => Some(&BARE_POPUP_CONTEXT_CLUES),
+      _ if EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block)
+        || INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block)
+        || EDIT_SERIES_BLOCKS.contains(&active_sonarr_block) =>
+      {
+        Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES)
+      }
+      ActiveSonarrBlock::AddSeriesPrompt
+      | ActiveSonarrBlock::AddSeriesSelectMonitor
+      | ActiveSonarrBlock::AddSeriesSelectSeriesType
+      | ActiveSonarrBlock::AddSeriesSelectQualityProfile
+      | ActiveSonarrBlock::AddSeriesSelectLanguageProfile
+      | ActiveSonarrBlock::AddSeriesSelectRootFolder
+      | ActiveSonarrBlock::AddSeriesTagsInput
+      | ActiveSonarrBlock::SystemTaskStartConfirmPrompt => Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES),
+      _ if ADD_SERIES_BLOCKS.contains(&active_sonarr_block) => {
+        Some(&ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES)
+      }
+      ActiveSonarrBlock::SystemTasks => Some(&SYSTEM_TASKS_CONTEXT_CLUES),
+      _ => app
+        .data
+        .sonarr_data
+        .main_tabs
+        .get_active_route_contextual_help(),
+    }
+  }
+}

src/app/sonarr/sonarr_context_clues_tests.rs

@@ -0,0 +1,654 @@
+#[cfg(test)]
+mod tests {
+  use crate::app::context_clues::{
+    BARE_POPUP_CONTEXT_CLUES, BLOCKLIST_CONTEXT_CLUES, CONFIRMATION_PROMPT_CONTEXT_CLUES,
+    ContextClue, ContextClueProvider, DOWNLOADS_CONTEXT_CLUES, HISTORY_CONTEXT_CLUES,
+    INDEXERS_CONTEXT_CLUES, ROOT_FOLDERS_CONTEXT_CLUES, SYSTEM_CONTEXT_CLUES,
+    SYSTEM_TASKS_CONTEXT_CLUES,
+  };
+  use crate::app::sonarr::sonarr_context_clues::{
+    SELECTABLE_EPISODE_DETAILS_CONTEXT_CLUES, SonarrContextClueProvider,
+  };
+  use crate::app::{
+    App,
+    key_binding::DEFAULT_KEYBINDINGS,
+    sonarr::sonarr_context_clues::{
+      ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES, EPISODE_DETAILS_CONTEXT_CLUES,
+      MANUAL_EPISODE_SEARCH_CONTEXT_CLUES, MANUAL_SEASON_SEARCH_CONTEXT_CLUES,
+      SEASON_DETAILS_CONTEXT_CLUES, SEASON_HISTORY_CONTEXT_CLUES, SERIES_CONTEXT_CLUES,
+      SERIES_DETAILS_CONTEXT_CLUES, SERIES_HISTORY_CONTEXT_CLUES,
+    },
+  };
+  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
+  use crate::models::servarr_data::sonarr::modals::{EpisodeDetailsModal, SeasonDetailsModal};
+  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
+  use rstest::rstest;
+
+  #[test]
+  fn test_add_series_search_results_context_clues() {
+    let mut add_series_search_results_context_clues_iter =
+      ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      add_series_search_results_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      add_series_search_results_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "edit search")
+    );
+    assert_none!(add_series_search_results_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_series_context_clues() {
+    let mut series_context_clues_iter = SERIES_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
+        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, "update all")
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      series_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
+    );
+    assert_none!(series_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_series_history_context_clues() {
+    let mut series_history_context_clues_iter = SERIES_HISTORY_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      series_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
+    );
+    assert_none!(series_history_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_series_details_context_clues() {
+    let mut series_details_context_clues_iter = SERIES_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
+        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "season details")
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      series_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(series_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_season_details_context_clues() {
+    let mut season_details_context_clues_iter = SEASON_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.toggle_monitoring,
+        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
+      )
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "episode details")
+    );
+    assert_some_eq_x!(
+      season_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.delete, "delete episode")
+    );
+    assert_none!(season_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_season_history_context_clues() {
+    let mut season_history_context_clues_iter = SEASON_HISTORY_CONTEXT_CLUES.iter();
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      season_history_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
+    );
+    assert_none!(season_history_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_manual_season_search_context_clues() {
+    let mut manual_season_search_context_clues_iter = MANUAL_SEASON_SEARCH_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      manual_season_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_season_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_season_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      manual_season_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      manual_season_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(manual_season_search_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_manual_episode_search_context_clues() {
+    let mut manual_episode_search_context_clues_iter = MANUAL_EPISODE_SEARCH_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      manual_episode_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_episode_search_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      manual_episode_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
+    );
+    assert_some_eq_x!(
+      manual_episode_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      manual_episode_search_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(manual_episode_search_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_episode_details_context_clues() {
+    let mut episode_details_context_clues_iter = EPISODE_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(episode_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_selectable_episode_details_context_clues() {
+    let mut episode_details_context_clues_iter = SELECTABLE_EPISODE_DETAILS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.refresh,
+        DEFAULT_KEYBINDINGS.refresh.desc
+      )
+    );
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(
+        DEFAULT_KEYBINDINGS.auto_search,
+        DEFAULT_KEYBINDINGS.auto_search.desc
+      )
+    );
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "details")
+    );
+    assert_some_eq_x!(
+      episode_details_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(episode_details_context_clues_iter.next());
+  }
+
+  #[test]
+  fn test_system_tasks_context_clues() {
+    let mut system_tasks_context_clues_iter = SYSTEM_TASKS_CONTEXT_CLUES.iter();
+
+    assert_some_eq_x!(
+      system_tasks_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.submit, "start task")
+    );
+    assert_some_eq_x!(
+      system_tasks_context_clues_iter.next(),
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
+    );
+    assert_none!(system_tasks_context_clues_iter.next());
+  }
+
+  #[test]
+  #[should_panic(
+    expected = "SonarrContextClueProvider::get_context_clues called with non-Sonarr route"
+  )]
+  fn test_sonarr_context_clue_provider_get_context_clues_non_sonarr_route() {
+    let mut app = App::test_default();
+    app.push_navigation_stack(ActiveRadarrBlock::default().into());
+
+    SonarrContextClueProvider::get_context_clues(&mut app);
+  }
+
+  #[rstest]
+  #[case(0, ActiveSonarrBlock::SeriesDetails, &SERIES_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveSonarrBlock::SeriesHistory, &SERIES_HISTORY_CONTEXT_CLUES)]
+  fn test_sonarr_context_clue_provider_series_info_tabs(
+    #[case] index: usize,
+    #[case] active_sonarr_block: ActiveSonarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    app.data.sonarr_data = SonarrData::default();
+    app.data.sonarr_data.series_info_tabs.set_index(index);
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  #[case(0, ActiveSonarrBlock::SeasonDetails, &SEASON_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveSonarrBlock::SeasonHistory, &SEASON_HISTORY_CONTEXT_CLUES)]
+  #[case(2, ActiveSonarrBlock::ManualSeasonSearch, &MANUAL_SEASON_SEARCH_CONTEXT_CLUES)]
+  fn test_sonarr_context_clue_provider_season_details_tabs(
+    #[case] index: usize,
+    #[case] active_sonarr_block: ActiveSonarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    let mut season_details_modal = SeasonDetailsModal::default();
+    season_details_modal.season_details_tabs.set_index(index);
+    let sonarr_data = SonarrData {
+      season_details_modal: Some(season_details_modal),
+      ..SonarrData::default()
+    };
+    app.data.sonarr_data = sonarr_data;
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  #[case(0, ActiveSonarrBlock::EpisodeDetails, &EPISODE_DETAILS_CONTEXT_CLUES)]
+  #[case(1, ActiveSonarrBlock::EpisodeHistory, &SELECTABLE_EPISODE_DETAILS_CONTEXT_CLUES)]
+  #[case(2, ActiveSonarrBlock::EpisodeFile, &EPISODE_DETAILS_CONTEXT_CLUES)]
+  #[case(3, ActiveSonarrBlock::ManualEpisodeSearch, &MANUAL_EPISODE_SEARCH_CONTEXT_CLUES)]
+  fn test_sonarr_context_clue_provider_episode_details_tabs(
+    #[case] index: usize,
+    #[case] active_sonarr_block: ActiveSonarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    let mut episode_details_modal = EpisodeDetailsModal::default();
+    episode_details_modal.episode_details_tabs.set_index(index);
+    let sonarr_data = SonarrData {
+      season_details_modal: Some(SeasonDetailsModal {
+        episode_details_modal: Some(episode_details_modal),
+        ..SeasonDetailsModal::default()
+      }),
+      ..SonarrData::default()
+    };
+    app.data.sonarr_data = sonarr_data;
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_bare_popup_context_clues(
+    #[values(
+      ActiveSonarrBlock::TestAllIndexers,
+      ActiveSonarrBlock::AddSeriesSearchInput,
+      ActiveSonarrBlock::AddSeriesEmptySearchResults,
+      ActiveSonarrBlock::SystemLogs,
+      ActiveSonarrBlock::SystemUpdates
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &BARE_POPUP_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_confirmation_prompt_context_clues(
+    #[values(
+      ActiveSonarrBlock::AddSeriesPrompt,
+      ActiveSonarrBlock::AddSeriesSelectMonitor,
+      ActiveSonarrBlock::AddSeriesSelectSeriesType,
+      ActiveSonarrBlock::AddSeriesSelectQualityProfile,
+      ActiveSonarrBlock::AddSeriesSelectLanguageProfile,
+      ActiveSonarrBlock::AddSeriesSelectRootFolder,
+      ActiveSonarrBlock::AddSeriesTagsInput,
+      ActiveSonarrBlock::SystemTaskStartConfirmPrompt
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_confirmation_prompt_popup_clues_edit_indexer_blocks(
+    #[values(
+      ActiveSonarrBlock::EditIndexerPrompt,
+      ActiveSonarrBlock::EditIndexerConfirmPrompt,
+      ActiveSonarrBlock::EditIndexerApiKeyInput,
+      ActiveSonarrBlock::EditIndexerNameInput,
+      ActiveSonarrBlock::EditIndexerSeedRatioInput,
+      ActiveSonarrBlock::EditIndexerToggleEnableRss,
+      ActiveSonarrBlock::EditIndexerToggleEnableAutomaticSearch,
+      ActiveSonarrBlock::EditIndexerToggleEnableInteractiveSearch,
+      ActiveSonarrBlock::EditIndexerPriorityInput,
+      ActiveSonarrBlock::EditIndexerUrlInput,
+      ActiveSonarrBlock::EditIndexerTagsInput
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_confirmation_prompt_popup_clues_indexer_settings_blocks(
+    #[values(
+      ActiveSonarrBlock::AllIndexerSettingsPrompt,
+      ActiveSonarrBlock::IndexerSettingsConfirmPrompt,
+      ActiveSonarrBlock::IndexerSettingsMaximumSizeInput,
+      ActiveSonarrBlock::IndexerSettingsMinimumAgeInput,
+      ActiveSonarrBlock::IndexerSettingsRetentionInput,
+      ActiveSonarrBlock::IndexerSettingsRssSyncIntervalInput
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_confirmation_prompt_popup_clues_edit_series_blocks(
+    #[values(
+      ActiveSonarrBlock::EditSeriesPrompt,
+      ActiveSonarrBlock::EditSeriesConfirmPrompt,
+      ActiveSonarrBlock::EditSeriesPathInput,
+      ActiveSonarrBlock::EditSeriesSelectSeriesType,
+      ActiveSonarrBlock::EditSeriesSelectQualityProfile,
+      ActiveSonarrBlock::EditSeriesSelectLanguageProfile,
+      ActiveSonarrBlock::EditSeriesTagsInput,
+      ActiveSonarrBlock::EditSeriesToggleMonitored,
+      ActiveSonarrBlock::EditSeriesToggleSeasonFolder
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  fn test_sonarr_context_clue_provider_add_series_search_results_clues(
+    #[values(
+      ActiveSonarrBlock::AddSeriesAlreadyInLibrary,
+      ActiveSonarrBlock::AddSeriesSearchResults
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::test_default();
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES);
+  }
+
+  #[test]
+  fn test_sonarr_context_clue_provider_system_tasks_clues() {
+    let mut app = App::test_default();
+
+    app.push_navigation_stack(ActiveSonarrBlock::SystemTasks.into());
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES);
+  }
+
+  #[rstest]
+  #[case(0, ActiveSonarrBlock::Series, &SERIES_CONTEXT_CLUES)]
+  #[case(1, ActiveSonarrBlock::Downloads, &DOWNLOADS_CONTEXT_CLUES)]
+  #[case(2, ActiveSonarrBlock::Blocklist, &BLOCKLIST_CONTEXT_CLUES)]
+  #[case(3, ActiveSonarrBlock::History, &HISTORY_CONTEXT_CLUES)]
+  #[case(4, ActiveSonarrBlock::RootFolders, &ROOT_FOLDERS_CONTEXT_CLUES)]
+  #[case(5, ActiveSonarrBlock::Indexers, &INDEXERS_CONTEXT_CLUES)]
+  #[case(6, ActiveSonarrBlock::System, &SYSTEM_CONTEXT_CLUES)]
+  fn test_sonarr_context_clue_provider_sonarr_tabs(
+    #[case] index: usize,
+    #[case] active_sonarr_block: ActiveSonarrBlock,
+    #[case] expected_context_clues: &[ContextClue],
+  ) {
+    let mut app = App::test_default();
+    app.data.sonarr_data = SonarrData::default();
+    app.data.sonarr_data.main_tabs.set_index(index);
+    app.push_navigation_stack(active_sonarr_block.into());
+
+    let context_clues = SonarrContextClueProvider::get_context_clues(&mut app);
+
+    assert_some_eq_x!(context_clues, expected_context_clues);
+  }
+}

src/app/sonarr/sonarr_tests.rs

@@ -0,0 +1,881 @@
+#[cfg(test)]
+mod tests {
+  mod sonarr_tests {
+    use pretty_assertions::{assert_eq, assert_str_eq};
+    use tokio::sync::mpsc;
+
+    use crate::models::servarr_data::sonarr::sonarr_data::sonarr_test_utils::utils::create_test_sonarr_data;
+    use crate::models::servarr_models::Indexer;
+    use crate::models::sonarr_models::Episode;
+    use crate::{
+      app::App,
+      models::{
+        servarr_data::sonarr::{
+          modals::{EpisodeDetailsModal, SeasonDetailsModal},
+          sonarr_data::ActiveSonarrBlock,
+        },
+        sonarr_models::{Season, Series, SonarrRelease},
+      },
+      network::{NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_dispatch_by_blocklist_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Blocklist)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::ListSeries.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetBlocklist.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeriesHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetSeriesHistory(1).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_details_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app.data.sonarr_data.series.set_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeriesDetails)
+        .await;
+
+      assert!(!app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::ListSeries.into()
+      );
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+      assert_eq!(app.tick_count, 0);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_season_details_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeasonDetails)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodes(1).into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeFiles(1).into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_season_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+      app.data.sonarr_data.seasons.set_items(vec![Season {
+        season_number: 1,
+        ..Season::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeasonHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetSeasonHistory(1, 1).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_season_history_block_no_op_when_seasons_table_is_empty() {
+      let (mut app, _) = construct_app_unit();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeasonHistory)
+        .await;
+
+      assert!(!app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_season_search_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+      app.data.sonarr_data.seasons.set_items(vec![Season {
+        season_number: 1,
+        ..Season::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualSeasonSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetSeasonReleases(1, 1).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_season_search_block_is_loading() {
+      let mut app = App {
+        is_loading: true,
+        ..App::test_default()
+      };
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualSeasonSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_season_search_block_season_releases_non_empty() {
+      let mut app = App::test_default();
+      let mut season_details_modal = SeasonDetailsModal::default();
+      season_details_modal
+        .season_releases
+        .set_items(vec![SonarrRelease::default()]);
+      app.data.sonarr_data.season_details_modal = Some(season_details_modal);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualSeasonSearch)
+        .await;
+
+      assert!(!app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_details_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data = create_test_sonarr_data();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeDetails)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeDetails(0).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_file_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data = create_test_sonarr_data();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeFile)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeDetails(0).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut season_details_modal = SeasonDetailsModal::default();
+      season_details_modal.episodes.set_items(vec![Episode {
+        id: 1,
+        ..Episode::default()
+      }]);
+      app.data.sonarr_data.season_details_modal = Some(season_details_modal);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeHistory(1).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_episode_search_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut season_details_modal = SeasonDetailsModal {
+        episode_details_modal: Some(EpisodeDetailsModal::default()),
+        ..SeasonDetailsModal::default()
+      };
+      season_details_modal.episodes.set_items(vec![Episode {
+        id: 1,
+        ..Episode::default()
+      }]);
+      app.data.sonarr_data.season_details_modal = Some(season_details_modal);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualEpisodeSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeReleases(1).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_episode_search_block_is_loading() {
+      let mut app = App {
+        is_loading: true,
+        ..App::test_default()
+      };
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualEpisodeSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_episode_search_block_episode_releases_non_empty() {
+      let mut app = App::test_default();
+      let mut episode_details_modal = EpisodeDetailsModal::default();
+      episode_details_modal
+        .episode_releases
+        .set_items(vec![SonarrRelease::default()]);
+      let season_details_modal = SeasonDetailsModal {
+        episode_details_modal: Some(episode_details_modal),
+        ..SeasonDetailsModal::default()
+      };
+      app.data.sonarr_data.season_details_modal = Some(season_details_modal);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualEpisodeSearch)
+        .await;
+
+      assert!(!app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::History)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetHistory(500).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_downloads_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Downloads)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_root_folders_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::RootFolders)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Series)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::ListSeries.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_indexers_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Indexers)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetIndexers.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_all_indexer_settings_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::AllIndexerSettingsPrompt)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetAllIndexerSettings.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_test_indexer_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.indexers.set_items(vec![Indexer {
+        id: 1,
+        ..Indexer::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::TestIndexer)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::TestIndexer(1).into()
+      );
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_test_all_indexers_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::TestAllIndexers)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::TestAllIndexers.into()
+      );
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_system_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::System)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTasks.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQueuedEvents.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLogs(500).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_system_updates_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SystemUpdates)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetUpdates.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_add_series_search_results_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.add_series_search = Some("test search".into());
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::AddSeriesSearchResults)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::SearchNewSeries("test search".into()).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_check_for_sonarr_prompt_action_no_prompt_confirm() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.prompt_confirm = false;
+
+      app.check_for_sonarr_prompt_action().await;
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.should_refresh);
+    }
+
+    #[tokio::test]
+    async fn test_check_for_sonarr_prompt_action() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.prompt_confirm_action = Some(SonarrEvent::GetStatus);
+
+      app.check_for_sonarr_prompt_action().await;
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.should_refresh);
+      assert_eq!(app.data.sonarr_data.prompt_confirm_action, None);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_refresh_metadata() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_routing = true;
+
+      app.refresh_sonarr_metadata().await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDiskSpace.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.is_loading);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_first_render() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_first_render = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDiskSpace.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.is_first_render);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_routing() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_routing = true;
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_routing_while_long_request_is_running_should_cancel_request() {
+      let (mut app, _) = construct_app_unit();
+      app.is_routing = true;
+      app.should_refresh = false;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert!(app.cancellation_token.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_should_refresh() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(app.should_refresh);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_should_refresh_does_not_cancel_prompt_requests() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_loading = true;
+      app.is_routing = true;
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(app.is_loading);
+      assert!(app.should_refresh);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.cancellation_token.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_network_tick_frequency() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.tick_count = 2;
+      app.tick_until_poll = 2;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads(500).into()
+      );
+      assert!(app.is_loading);
+    }
+
+    #[tokio::test]
+    async fn test_populate_seasons_table_unfiltered() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app.populate_seasons_table().await;
+
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+      assert_str_eq!(
+        app.data.sonarr_data.seasons.items[0]
+          .title
+          .as_ref()
+          .unwrap(),
+        "Season 0"
+      );
+    }
+
+    #[tokio::test]
+    async fn test_populate_seasons_table_filtered() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.series.set_filtered_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app.populate_seasons_table().await;
+
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+      assert_str_eq!(
+        app.data.sonarr_data.seasons.items[0]
+          .title
+          .as_ref()
+          .unwrap(),
+        "Season 0"
+      );
+    }
+
+    #[tokio::test]
+    async fn test_extract_episode_id() {
+      let mut app = App::test_default();
+      let mut season_details_modal = SeasonDetailsModal::default();
+      season_details_modal.episodes.set_items(vec![Episode {
+        id: 1,
+        ..Episode::default()
+      }]);
+      app.data.sonarr_data.season_details_modal = Some(season_details_modal);
+
+      assert_eq!(app.extract_episode_id().await, 1);
+    }
+
+    #[tokio::test]
+    #[should_panic(expected = "Season details have not been loaded")]
+    async fn test_extract_episode_id_requires_season_details_modal_to_be_some() {
+      let app = App::test_default();
+
+      assert_eq!(app.extract_episode_id().await, 0);
+    }
+
+    #[tokio::test]
+    async fn test_extract_series_id() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+
+      assert_eq!(app.extract_series_id().await, 1);
+    }
+
+    #[tokio::test]
+    async fn test_extract_series_id_season_number_tuple() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        id: 1,
+        ..Series::default()
+      }]);
+      app.data.sonarr_data.seasons.set_items(vec![Season {
+        season_number: 1,
+        ..Season::default()
+      }]);
+
+      assert_eq!(app.extract_series_id_season_number_tuple().await, (1, 1));
+    }
+
+    #[tokio::test]
+    async fn test_extract_add_new_series_search_query() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.add_series_search = Some("test search".into());
+
+      assert_str_eq!(
+        app.extract_add_new_series_search_query().await,
+        "test search"
+      );
+    }
+
+    #[tokio::test]
+    #[should_panic(expected = "Add series search is empty")]
+    async fn test_extract_add_new_series_search_query_panics_when_the_query_is_not_set() {
+      let app = App::test_default();
+
+      app.extract_add_new_series_search_query().await;
+    }
+
+    #[tokio::test]
+    async fn test_extract_sonarr_indexer_id() {
+      let mut app = App::test_default();
+      app.data.sonarr_data.indexers.set_items(vec![Indexer {
+        id: 1,
+        ..Indexer::default()
+      }]);
+
+      assert_eq!(app.extract_sonarr_indexer_id().await, 1);
+    }
+
+    fn construct_app_unit<'a>() -> (App<'a>, mpsc::Receiver<NetworkEvent>) {
+      let (sync_network_tx, sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
+      let mut app = App {
+        network_tx: Some(sync_network_tx),
+        tick_count: 1,
+        is_first_render: false,
+        ..App::test_default()
+      };
+      app.data.sonarr_data.prompt_confirm = true;
+
+      (app, sync_network_rx)
+    }
+  }
+}

src/cli/cli_tests.rs

@@ -2,29 +2,44 @@
 mod tests {
   use std::sync::Arc;
 
-  use clap::{error::ErrorKind, CommandFactory};
+  use clap::{CommandFactory, error::ErrorKind};
   use mockall::predicate::eq;
   use rstest::rstest;
   use serde_json::json;
   use tokio::sync::Mutex;
 
+  use crate::cli::lidarr::LidarrCommand;
+  use crate::network::lidarr_network::LidarrEvent;
   use crate::{
-    app::App,
-    cli::{handle_command, mutex_flags_or_option, radarr::RadarrCommand},
-    models::{
-      radarr_models::{BlocklistItem, BlocklistResponse, RadarrSerdeable},
-      Serdeable,
-    },
-    network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
     Cli,
+    app::App,
+    cli::{handle_command, mutex_flags_or_option, radarr::RadarrCommand, sonarr::SonarrCommand},
+    models::{
+      Serdeable,
+      lidarr_models::{
+        BlocklistItem as LidarrBlocklistItem, BlocklistResponse as LidarrBlocklistResponse,
+        LidarrSerdeable,
+      },
+      radarr_models::{
+        BlocklistItem as RadarrBlocklistItem, BlocklistResponse as RadarrBlocklistResponse,
+        RadarrSerdeable,
+      },
+      sonarr_models::{
+        BlocklistItem as SonarrBlocklistItem, BlocklistResponse as SonarrBlocklistResponse,
+        SonarrSerdeable,
+      },
+    },
+    network::{
+      MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent, sonarr_network::SonarrEvent,
+    },
   };
   use pretty_assertions::assert_eq;
 
-  #[test]
+  #[rstest]
-  fn test_radarr_subcommand_requires_subcommand() {
+  fn test_servarr_subcommand_requires_subcommand(#[values("radarr", "sonarr")] subcommand: &str) {
-    let result = Cli::command().try_get_matches_from(["managarr", "radarr"]);
+    let result = Cli::command().try_get_matches_from(["managarr", subcommand]);
 
-    assert!(result.is_err());
+    assert_err!(&result);
     assert_eq!(
       result.unwrap_err().kind(),
       ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
@@ -36,14 +51,28 @@ mod tests {
     let result =
       Cli::command().try_get_matches_from(["managarr", "radarr", "get", "all-indexer-settings"]);
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
+  }
+
+  #[test]
+  fn test_sonarr_subcommand_delegates_to_sonarr() {
+    let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "series"]);
+
+    assert_ok!(&result);
+  }
+
+  #[test]
+  fn test_lidarr_subcommand_delegates_to_lidarr() {
+    let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "artists"]);
+
+    assert_ok!(&result);
   }
 
   #[test]
   fn test_completions_requires_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions"]);
 
-    assert!(result.is_err());
+    assert_err!(&result);
     assert_eq!(
       result.unwrap_err().kind(),
       ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
@@ -54,7 +83,7 @@ mod tests {
   fn test_completions_invalid_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions", "test"]);
 
-    assert!(result.is_err());
+    assert_err!(&result);
     assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
   }
 
@@ -62,7 +91,7 @@ mod tests {
   fn test_completions_satisfied_with_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions", "bash"]);
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
   }
 
   #[rstest]
@@ -106,8 +135,8 @@ mod tests {
       .times(1)
       .returning(|_| {
         Ok(Serdeable::Radarr(RadarrSerdeable::BlocklistResponse(
-          BlocklistResponse {
+          RadarrBlocklistResponse {
-            records: vec![BlocklistItem::default()],
+            records: vec![RadarrBlocklistItem::default()],
           },
         )))
       });
@@ -120,11 +149,73 @@ mod tests {
           json!({"testResponse": "response"}),
         )))
       });
-    let app_arc = Arc::new(Mutex::new(App::default()));
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let claer_blocklist_command = RadarrCommand::ClearBlocklist.into();
+    let clear_blocklist_command = RadarrCommand::ClearBlocklist.into();
 
-    let result = handle_command(&app_arc, claer_blocklist_command, &mut mock_network).await;
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
+  }
+
+  #[tokio::test]
+  async fn test_cli_handler_delegates_sonarr_commands_to_the_sonarr_cli_handler() {
+    let mut mock_network = MockNetworkTrait::new();
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(SonarrEvent::GetBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Sonarr(SonarrSerdeable::BlocklistResponse(
+          SonarrBlocklistResponse {
+            records: vec![SonarrBlocklistItem::default()],
+          },
+        )))
+      });
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(SonarrEvent::ClearBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+          json!({"testResponse": "response"}),
+        )))
+      });
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
+    let clear_blocklist_command = SonarrCommand::ClearBlocklist.into();
+
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
+
+    assert_ok!(&result);
+  }
+
+  #[tokio::test]
+  async fn test_cli_handler_delegates_lidarr_commands_to_the_lidarr_cli_handler() {
+    let mut mock_network = MockNetworkTrait::new();
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(LidarrEvent::GetBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Lidarr(LidarrSerdeable::BlocklistResponse(
+          LidarrBlocklistResponse {
+            records: vec![LidarrBlocklistItem::default()],
+          },
+        )))
+      });
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(LidarrEvent::ClearBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+          json!({"testResponse": "response"}),
+        )))
+      });
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
+    let clear_blocklist_command = LidarrCommand::ClearBlocklist.into();
+
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
+
+    assert_ok!(&result);
   }
 }

src/cli/lidarr/add_command_handler.rs

@@ -0,0 +1,223 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::{ArgAction, Subcommand};
+use tokio::sync::Mutex;
+
+use super::LidarrCommand;
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  models::lidarr_models::{
+    AddArtistBody, AddArtistOptions, AddLidarrRootFolderBody, MonitorType, NewItemMonitorType,
+  },
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+#[cfg(test)]
+#[path = "add_command_handler_tests.rs"]
+mod add_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrAddCommand {
+  #[command(about = "Add a new artist to your Lidarr library")]
+  Artist {
+    #[arg(
+      long,
+      help = "The MusicBrainz foreign artist ID of the artist you wish to add to your library",
+      required = true
+    )]
+    foreign_artist_id: String,
+    #[arg(long, help = "The name of the artist", required = true)]
+    artist_name: String,
+    #[arg(
+      long,
+      help = "The root folder path where all artist data and metadata should live",
+      required = true
+    )]
+    root_folder_path: String,
+    #[arg(
+      long,
+      help = "The ID of the quality profile to use for this artist",
+      required = true
+    )]
+    quality_profile_id: i64,
+    #[arg(
+      long,
+      help = "The ID of the metadata profile to use for this artist",
+      required = true
+    )]
+    metadata_profile_id: i64,
+    #[arg(long, help = "Disable monitoring for this artist")]
+    disable_monitoring: bool,
+    #[arg(
+      long,
+      help = "Tag IDs to tag the artist with",
+      value_parser,
+      action = ArgAction::Append
+    )]
+    tag: Vec<i64>,
+    #[arg(
+      long,
+      help = "What Lidarr should monitor for this artist",
+      value_enum,
+      default_value_t = MonitorType::default()
+    )]
+    monitor: MonitorType,
+    #[arg(
+      long,
+      help = "How Lidarr should monitor new items for this artist",
+      value_enum,
+      default_value_t = NewItemMonitorType::default()
+    )]
+    monitor_new_items: NewItemMonitorType,
+    #[arg(
+      long,
+      help = "Tell Lidarr to not start a search for missing albums once the artist is added to your library"
+    )]
+    no_search_for_missing_albums: bool,
+  },
+  #[command(about = "Add a new root folder")]
+  RootFolder {
+    #[arg(long, help = "The name of the root folder", required = true)]
+    name: String,
+    #[arg(long, help = "The path of the new root folder", required = true)]
+    root_folder_path: String,
+    #[arg(
+      long,
+      help = "The ID of the default quality profile for artists in this root folder",
+      required = true
+    )]
+    quality_profile_id: i64,
+    #[arg(
+      long,
+      help = "The ID of the default metadata profile for artists in this root folder",
+      required = true
+    )]
+    metadata_profile_id: i64,
+    #[arg(
+      long,
+      help = "The default monitor option for artists in this root folder",
+      value_enum,
+      default_value_t = MonitorType::default()
+    )]
+    monitor: MonitorType,
+    #[arg(
+      long,
+      help = "The default monitor new items option for artists in this root folder",
+      value_enum,
+      default_value_t = NewItemMonitorType::default()
+    )]
+    monitor_new_items: NewItemMonitorType,
+    #[arg(
+      long,
+      help = "Default tag IDs for artists in this root folder",
+      value_parser,
+      action = ArgAction::Append
+    )]
+    tag: Vec<i64>,
+  },
+  #[command(about = "Add new tag")]
+  Tag {
+    #[arg(long, help = "The name of the tag to be added", required = true)]
+    name: String,
+  },
+}
+
+impl From<LidarrAddCommand> for Command {
+  fn from(value: LidarrAddCommand) -> Self {
+    Command::Lidarr(LidarrCommand::Add(value))
+  }
+}
+
+pub(super) struct LidarrAddCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrAddCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrAddCommand> for LidarrAddCommandHandler<'a, 'b> {
+  fn with(
+    app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrAddCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrAddCommandHandler {
+      _app: app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrAddCommand::Artist {
+        foreign_artist_id,
+        artist_name,
+        root_folder_path,
+        quality_profile_id,
+        metadata_profile_id,
+        disable_monitoring,
+        tag: tags,
+        monitor,
+        monitor_new_items,
+        no_search_for_missing_albums,
+      } => {
+        let body = AddArtistBody {
+          foreign_artist_id,
+          artist_name,
+          monitored: !disable_monitoring,
+          root_folder_path,
+          quality_profile_id,
+          metadata_profile_id,
+          tags,
+          tag_input_string: None,
+          add_options: AddArtistOptions {
+            monitor,
+            monitor_new_items,
+            search_for_missing_albums: !no_search_for_missing_albums,
+          },
+        };
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::AddArtist(body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrAddCommand::RootFolder {
+        name,
+        root_folder_path,
+        quality_profile_id,
+        metadata_profile_id,
+        monitor,
+        monitor_new_items,
+        tag: tags,
+      } => {
+        let add_root_folder_body = AddLidarrRootFolderBody {
+          name,
+          path: root_folder_path,
+          default_quality_profile_id: quality_profile_id,
+          default_metadata_profile_id: metadata_profile_id,
+          default_monitor_option: monitor,
+          default_new_item_monitor_option: monitor_new_items,
+          default_tags: tags,
+          tag_input_string: None,
+        };
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::AddRootFolder(add_root_folder_body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrAddCommand::Tag { name } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::AddTag(name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/add_command_handler_tests.rs

@@ -0,0 +1,561 @@
+#[cfg(test)]
+mod tests {
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+
+  use crate::{
+    Cli,
+    cli::{
+      Command,
+      lidarr::{LidarrCommand, add_command_handler::LidarrAddCommand},
+    },
+    models::lidarr_models::{MonitorType, NewItemMonitorType},
+  };
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_add_command_from() {
+    let command = LidarrAddCommand::Tag {
+      name: String::new(),
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::Add(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_add_root_folder_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "add", "root-folder"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_root_folder_success() {
+      let expected_args = LidarrAddCommand::RootFolder {
+        name: "Music".to_owned(),
+        root_folder_path: "/nfs/test".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 1,
+        monitor: MonitorType::All,
+        monitor_new_items: NewItemMonitorType::All,
+        tag: vec![],
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "root-folder",
+        "--name",
+        "Music",
+        "--root-folder-path",
+        "/nfs/test",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_tag_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "add", "tag"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_tag_success() {
+      let expected_args = LidarrAddCommand::Tag {
+        name: "test".to_owned(),
+      };
+
+      let result = Cli::try_parse_from(["managarr", "lidarr", "add", "tag", "--name", "test"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type")
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_artist_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "add", "artist"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_requires_foreign_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--artist-name",
+        "Test",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_requires_artist_name() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_requires_root_folder_path() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_requires_quality_profile_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test",
+        "--root-folder-path",
+        "/music",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_requires_metadata_profile_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_artist_success_with_required_args_only() {
+      let expected_args = LidarrAddCommand::Artist {
+        foreign_artist_id: "test-id".to_owned(),
+        artist_name: "Test Artist".to_owned(),
+        root_folder_path: "/music".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 1,
+        disable_monitoring: false,
+        tag: vec![],
+        monitor: MonitorType::default(),
+        monitor_new_items: NewItemMonitorType::default(),
+        no_search_for_missing_albums: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test Artist",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type")
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_artist_success_with_all_args() {
+      let expected_args = LidarrAddCommand::Artist {
+        foreign_artist_id: "test-id".to_owned(),
+        artist_name: "Test Artist".to_owned(),
+        root_folder_path: "/music".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 2,
+        disable_monitoring: true,
+        tag: vec![1, 2],
+        monitor: MonitorType::Future,
+        monitor_new_items: NewItemMonitorType::New,
+        no_search_for_missing_albums: true,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test Artist",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "2",
+        "--disable-monitoring",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+        "--monitor",
+        "future",
+        "--monitor-new-items",
+        "new",
+        "--no-search-for-missing-albums",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type")
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_artist_monitor_type_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test Artist",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "2",
+        "--monitor",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_add_artist_new_item_monitor_type_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test Artist",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "2",
+        "--monitor-new-items",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_add_artist_tags_is_repeatable() {
+      let expected_args = LidarrAddCommand::Artist {
+        foreign_artist_id: "test-id".to_owned(),
+        artist_name: "Test Artist".to_owned(),
+        root_folder_path: "/music".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 2,
+        disable_monitoring: false,
+        tag: vec![1, 2],
+        monitor: MonitorType::default(),
+        monitor_new_items: NewItemMonitorType::default(),
+        no_search_for_missing_albums: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "add",
+        "artist",
+        "--foreign-artist-id",
+        "test-id",
+        "--artist-name",
+        "Test Artist",
+        "--root-folder-path",
+        "/music",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "2",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type")
+      };
+      assert_eq!(add_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::cli::CliCommandHandler;
+    use crate::cli::lidarr::add_command_handler::{LidarrAddCommand, LidarrAddCommandHandler};
+    use crate::models::Serdeable;
+    use crate::models::lidarr_models::{
+      AddArtistBody, AddArtistOptions, AddLidarrRootFolderBody, LidarrSerdeable, MonitorType,
+      NewItemMonitorType,
+    };
+    use crate::network::lidarr_network::LidarrEvent;
+    use crate::{
+      app::App,
+      network::{MockNetworkTrait, NetworkEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_add_root_folder_command() {
+      let expected_root_folder_path = "/nfs/test".to_owned();
+      let expected_add_root_folder_body = AddLidarrRootFolderBody {
+        name: "Music".to_owned(),
+        path: expected_root_folder_path.clone(),
+        default_quality_profile_id: 1,
+        default_metadata_profile_id: 1,
+        default_monitor_option: MonitorType::All,
+        default_new_item_monitor_option: NewItemMonitorType::All,
+        default_tags: vec![1, 2],
+        tag_input_string: None,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::AddRootFolder(expected_add_root_folder_body.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_root_folder_command = LidarrAddCommand::RootFolder {
+        name: "Music".to_owned(),
+        root_folder_path: expected_root_folder_path,
+        quality_profile_id: 1,
+        metadata_profile_id: 1,
+        monitor: MonitorType::All,
+        monitor_new_items: NewItemMonitorType::All,
+        tag: vec![1, 2],
+      };
+
+      let result =
+        LidarrAddCommandHandler::with(&app_arc, add_root_folder_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_add_tag_command() {
+      let expected_tag_name = "test".to_owned();
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::AddTag(expected_tag_name.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_tag_command = LidarrAddCommand::Tag {
+        name: expected_tag_name,
+      };
+
+      let result = LidarrAddCommandHandler::with(&app_arc, add_tag_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_add_artist_command() {
+      let expected_body = AddArtistBody {
+        foreign_artist_id: "test-id".to_owned(),
+        artist_name: "Test Artist".to_owned(),
+        monitored: false,
+        root_folder_path: "/music".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 1,
+        tags: vec![1, 2],
+        tag_input_string: None,
+        add_options: AddArtistOptions {
+          monitor: MonitorType::All,
+          monitor_new_items: NewItemMonitorType::All,
+          search_for_missing_albums: false,
+        },
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::AddArtist(expected_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_artist_command = LidarrAddCommand::Artist {
+        foreign_artist_id: "test-id".to_owned(),
+        artist_name: "Test Artist".to_owned(),
+        root_folder_path: "/music".to_owned(),
+        quality_profile_id: 1,
+        metadata_profile_id: 1,
+        disable_monitoring: true,
+        tag: vec![1, 2],
+        monitor: MonitorType::All,
+        monitor_new_items: NewItemMonitorType::All,
+        no_search_for_missing_albums: true,
+      };
+
+      let result = LidarrAddCommandHandler::with(&app_arc, add_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/delete_command_handler.rs

@@ -0,0 +1,181 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  models::lidarr_models::DeleteParams,
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+use super::LidarrCommand;
+
+#[cfg(test)]
+#[path = "delete_command_handler_tests.rs"]
+mod delete_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrDeleteCommand {
+  #[command(about = "Delete an album from your Lidarr library")]
+  Album {
+    #[arg(long, help = "The ID of the album to delete", required = true)]
+    album_id: i64,
+    #[arg(long, help = "Delete the album files from disk as well")]
+    delete_files_from_disk: bool,
+    #[arg(long, help = "Add a list exclusion for this album")]
+    add_list_exclusion: bool,
+  },
+  #[command(about = "Delete the specified item from the Lidarr blocklist")]
+  BlocklistItem {
+    #[arg(
+      long,
+      help = "The ID of the blocklist item to remove from the blocklist",
+      required = true
+    )]
+    blocklist_item_id: i64,
+  },
+  #[command(about = "Delete the specified track file from disk")]
+  TrackFile {
+    #[arg(long, help = "The ID of the track file to delete", required = true)]
+    track_file_id: i64,
+  },
+  #[command(about = "Delete an artist from your Lidarr library")]
+  Artist {
+    #[arg(long, help = "The ID of the artist to delete", required = true)]
+    artist_id: i64,
+    #[arg(long, help = "Delete the artist files from disk as well")]
+    delete_files_from_disk: bool,
+    #[arg(long, help = "Add a list exclusion for this artist")]
+    add_list_exclusion: bool,
+  },
+  #[command(about = "Delete the specified download")]
+  Download {
+    #[arg(long, help = "The ID of the download to delete", required = true)]
+    download_id: i64,
+  },
+  #[command(about = "Delete the indexer with the given ID")]
+  Indexer {
+    #[arg(long, help = "The ID of the indexer to delete", required = true)]
+    indexer_id: i64,
+  },
+  #[command(about = "Delete the root folder with the given ID")]
+  RootFolder {
+    #[arg(long, help = "The ID of the root folder to delete", required = true)]
+    root_folder_id: i64,
+  },
+  #[command(about = "Delete the tag with the specified ID")]
+  Tag {
+    #[arg(long, help = "The ID of the tag to delete", required = true)]
+    tag_id: i64,
+  },
+}
+
+impl From<LidarrDeleteCommand> for Command {
+  fn from(value: LidarrDeleteCommand) -> Self {
+    Command::Lidarr(LidarrCommand::Delete(value))
+  }
+}
+
+pub(super) struct LidarrDeleteCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrDeleteCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrDeleteCommand> for LidarrDeleteCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrDeleteCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrDeleteCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrDeleteCommand::Album {
+        album_id,
+        delete_files_from_disk,
+        add_list_exclusion,
+      } => {
+        let delete_album_params = DeleteParams {
+          id: album_id,
+          delete_files: delete_files_from_disk,
+          add_import_list_exclusion: add_list_exclusion,
+        };
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteAlbum(delete_album_params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::BlocklistItem { blocklist_item_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteBlocklistItem(blocklist_item_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::TrackFile { track_file_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteTrackFile(track_file_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::Artist {
+        artist_id,
+        delete_files_from_disk,
+        add_list_exclusion,
+      } => {
+        let delete_artist_params = DeleteParams {
+          id: artist_id,
+          delete_files: delete_files_from_disk,
+          add_import_list_exclusion: add_list_exclusion,
+        };
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteArtist(delete_artist_params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::Download { download_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteDownload(download_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::Indexer { indexer_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::RootFolder { root_folder_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteRootFolder(root_folder_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrDeleteCommand::Tag { tag_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteTag(tag_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/delete_command_handler_tests.rs

@@ -0,0 +1,595 @@
+#[cfg(test)]
+mod tests {
+  use crate::{
+    Cli,
+    cli::{
+      Command,
+      lidarr::{LidarrCommand, delete_command_handler::LidarrDeleteCommand},
+    },
+  };
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_delete_command_from() {
+    let command = LidarrDeleteCommand::Artist {
+      artist_id: 1,
+      delete_files_from_disk: false,
+      add_list_exclusion: false,
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::Delete(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_delete_album_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "album"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_album_defaults() {
+      let expected_args = LidarrDeleteCommand::Album {
+        album_id: 1,
+        delete_files_from_disk: false,
+        add_list_exclusion: false,
+      };
+
+      let result =
+        Cli::try_parse_from(["managarr", "lidarr", "delete", "album", "--album-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_album_all_args_defined() {
+      let expected_args = LidarrDeleteCommand::Album {
+        album_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "album",
+        "--album-id",
+        "1",
+        "--delete-files-from-disk",
+        "--add-list-exclusion",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_blocklist_item_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "blocklist-item"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_blocklist_item_success() {
+      let expected_args = LidarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "blocklist-item",
+        "--blocklist-item-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_track_file_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "track-file"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_track_file_success() {
+      let expected_args = LidarrDeleteCommand::TrackFile { track_file_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "track-file",
+        "--track-file-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_artist_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "artist"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_artist_defaults() {
+      let expected_args = LidarrDeleteCommand::Artist {
+        artist_id: 1,
+        delete_files_from_disk: false,
+        add_list_exclusion: false,
+      };
+
+      let result =
+        Cli::try_parse_from(["managarr", "lidarr", "delete", "artist", "--artist-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_artist_all_args_defined() {
+      let expected_args = LidarrDeleteCommand::Artist {
+        artist_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "artist",
+        "--artist-id",
+        "1",
+        "--delete-files-from-disk",
+        "--add-list-exclusion",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_download_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "download"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_download_success() {
+      let expected_args = LidarrDeleteCommand::Download { download_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "download",
+        "--download-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_indexer_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "indexer"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_indexer_success() {
+      let expected_args = LidarrDeleteCommand::Indexer { indexer_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "indexer",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_root_folder_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "root-folder"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_root_folder_success() {
+      let expected_args = LidarrDeleteCommand::RootFolder { root_folder_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "root-folder",
+        "--root-folder-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_tag_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "tag"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_tag_success() {
+      let expected_args = LidarrDeleteCommand::Tag { tag_id: 1 };
+
+      let result = Cli::try_parse_from(["managarr", "lidarr", "delete", "tag", "--tag-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        lidarr::delete_command_handler::{LidarrDeleteCommand, LidarrDeleteCommandHandler},
+      },
+      models::{
+        Serdeable,
+        lidarr_models::{DeleteParams, LidarrSerdeable},
+      },
+      network::{MockNetworkTrait, NetworkEvent, lidarr_network::LidarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_delete_album_command() {
+      let expected_delete_album_params = DeleteParams {
+        id: 1,
+        delete_files: true,
+        add_import_list_exclusion: true,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteAlbum(expected_delete_album_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_album_command = LidarrDeleteCommand::Album {
+        album_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_album_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_blocklist_item_command() {
+      let expected_blocklist_item_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_blocklist_item_command = LidarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = LidarrDeleteCommandHandler::with(
+        &app_arc,
+        delete_blocklist_item_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_track_file_command() {
+      let expected_track_file_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteTrackFile(expected_track_file_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_track_file_command = LidarrDeleteCommand::TrackFile { track_file_id: 1 };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_track_file_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_artist_command() {
+      let expected_delete_artist_params = DeleteParams {
+        id: 1,
+        delete_files: true,
+        add_import_list_exclusion: true,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteArtist(expected_delete_artist_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_artist_command = LidarrDeleteCommand::Artist {
+        artist_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_artist_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_download_command() {
+      let expected_download_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteDownload(expected_download_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_download_command = LidarrDeleteCommand::Download { download_id: 1 };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_download_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_indexer_command() {
+      let expected_indexer_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteIndexer(expected_indexer_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_indexer_command = LidarrDeleteCommand::Indexer { indexer_id: 1 };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_indexer_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_root_folder_command() {
+      let expected_root_folder_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteRootFolder(expected_root_folder_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_root_folder_command = LidarrDeleteCommand::RootFolder { root_folder_id: 1 };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_root_folder_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_tag_command() {
+      let expected_tag_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteTag(expected_tag_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_tag_command = LidarrDeleteCommand::Tag { tag_id: 1 };
+
+      let result =
+        LidarrDeleteCommandHandler::with(&app_arc, delete_tag_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/edit_command_handler.rs

@@ -0,0 +1,343 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::{ArgAction, ArgGroup, Subcommand};
+use tokio::sync::Mutex;
+
+use super::LidarrCommand;
+use crate::models::Serdeable;
+use crate::models::lidarr_models::LidarrSerdeable;
+use crate::models::servarr_models::{EditIndexerParams, IndexerSettings};
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command, mutex_flags_or_option},
+  models::lidarr_models::{EditArtistParams, NewItemMonitorType},
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+#[cfg(test)]
+#[path = "edit_command_handler_tests.rs"]
+mod edit_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrEditCommand {
+  #[command(
+    about = "Edit and indexer settings that apply to all indexers",
+    group(
+      ArgGroup::new("edit_settings")
+      .args([
+        "maximum_size", 
+        "minimum_age", 
+        "retention", 
+        "rss_sync_interval", 
+      ]).required(true)
+      .multiple(true))
+  )]
+  AllIndexerSettings {
+    #[arg(
+      long,
+      help = "The maximum size for a release to be grabbed in MB. Set to zero to set to unlimited"
+    )]
+    maximum_size: Option<i64>,
+    #[arg(
+      long,
+      help = "Usenet only: Minimum age in minutes of NZBs before they are grabbed. Use this to give new releases time to propagate to your usenet provider."
+    )]
+    minimum_age: Option<i64>,
+    #[arg(
+      long,
+      help = "Usenet only: The retention time in days to retain releases. Set to zero to set for unlimited retention"
+    )]
+    retention: Option<i64>,
+    #[arg(
+      long,
+      help = "The RSS sync interval in minutes. Set to zero to disable (this will stop all automatic release grabbing)"
+    )]
+    rss_sync_interval: Option<i64>,
+  },
+  #[command(
+    about = "Edit preferences for the specified artist",
+    group(
+      ArgGroup::new("edit_artist")
+      .args([
+        "enable_monitoring",
+        "disable_monitoring",
+        "monitor_new_items",
+        "quality_profile_id",
+        "metadata_profile_id",
+        "root_folder_path",
+        "tag",
+        "clear_tags"
+      ]).required(true)
+      .multiple(true))
+  )]
+  Artist {
+    #[arg(
+      long,
+      help = "The ID of the artist whose settings you want to edit",
+      required = true
+    )]
+    artist_id: i64,
+    #[arg(
+      long,
+      help = "Enable monitoring of this artist in Lidarr so Lidarr will automatically download releases from this artist if they are available",
+      conflicts_with = "disable_monitoring"
+    )]
+    enable_monitoring: bool,
+    #[arg(
+      long,
+      help = "Disable monitoring of this artist so Lidarr does not automatically download releases from this artist if they are available",
+      conflicts_with = "enable_monitoring"
+    )]
+    disable_monitoring: bool,
+    #[arg(
+      long,
+      help = "How Lidarr should monitor new albums from this artist",
+      value_enum
+    )]
+    monitor_new_items: Option<NewItemMonitorType>,
+    #[arg(long, help = "The ID of the quality profile to use for this artist")]
+    quality_profile_id: Option<i64>,
+    #[arg(long, help = "The ID of the metadata profile to use for this artist")]
+    metadata_profile_id: Option<i64>,
+    #[arg(
+      long,
+      help = "The root folder path where all artist data and metadata should live"
+    )]
+    root_folder_path: Option<String>,
+    #[arg(
+      long,
+      help = "Tag IDs to tag this artist with",
+      value_parser,
+      action = ArgAction::Append,
+      conflicts_with = "clear_tags"
+    )]
+    tag: Option<Vec<i64>>,
+    #[arg(long, help = "Clear all tags on this artist", conflicts_with = "tag")]
+    clear_tags: bool,
+  },
+  #[command(
+    about = "Edit preferences for the specified indexer",
+    group(
+      ArgGroup::new("edit_indexer")
+      .args([
+        "name",
+        "enable_rss",
+        "disable_rss",
+        "enable_automatic_search",
+        "disable_automatic_search",
+        "enable_interactive_search",
+        "disable_automatic_search",
+        "url",
+        "api_key",
+        "seed_ratio",
+        "tag",
+        "priority",
+        "clear_tags"
+      ]).required(true)
+      .multiple(true))
+  )]
+  Indexer {
+    #[arg(
+      long,
+      help = "The ID of the indexer whose settings you wish to edit",
+      required = true
+    )]
+    indexer_id: i64,
+    #[arg(long, help = "The name of the indexer")]
+    name: Option<String>,
+    #[arg(
+      long,
+      help = "Indicate to Lidarr that this indexer should be used when Lidarr periodically looks for releases via RSS Sync",
+      conflicts_with = "disable_rss"
+    )]
+    enable_rss: bool,
+    #[arg(
+      long,
+      help = "Disable using this indexer when Lidarr periodically looks for releases via RSS Sync",
+      conflicts_with = "enable_rss"
+    )]
+    disable_rss: bool,
+    #[arg(
+      long,
+      help = "Indicate to Lidarr that this indexer should be used when automatic searches are performed via the UI or by Lidarr",
+      conflicts_with = "disable_automatic_search"
+    )]
+    enable_automatic_search: bool,
+    #[arg(
+      long,
+      help = "Disable using this indexer whenever automatic searches are performed via the UI or by Lidarr",
+      conflicts_with = "enable_automatic_search"
+    )]
+    disable_automatic_search: bool,
+    #[arg(
+      long,
+      help = "Indicate to Lidarr that this indexer should be used when an interactive search is used",
+      conflicts_with = "disable_interactive_search"
+    )]
+    enable_interactive_search: bool,
+    #[arg(
+      long,
+      help = "Disable using this indexer whenever an interactive search is performed",
+      conflicts_with = "enable_interactive_search"
+    )]
+    disable_interactive_search: bool,
+    #[arg(long, help = "The URL of the indexer")]
+    url: Option<String>,
+    #[arg(long, help = "The API key used to access the indexer's API")]
+    api_key: Option<String>,
+    #[arg(
+      long,
+      help = "The ratio a torrent should reach before stopping; Empty uses the download client's default. Ratio should be at least 1.0 and follow the indexer's rules"
+    )]
+    seed_ratio: Option<String>,
+    #[arg(
+      long,
+      help = "Only use this indexer for series with at least one matching tag ID. Leave blank to use with all series.",
+      value_parser,
+      action = ArgAction::Append,
+      conflicts_with = "clear_tags"
+    )]
+    tag: Option<Vec<i64>>,
+    #[arg(
+      long,
+      help = "Indexer Priority from 1 (Highest) to 50 (Lowest). Default: 25. Used when grabbing releases as a tiebreaker for otherwise equal releases, Lidarr will still use all enabled indexers for RSS Sync and Searching"
+    )]
+    priority: Option<i64>,
+    #[arg(long, help = "Clear all tags on this indexer", conflicts_with = "tag")]
+    clear_tags: bool,
+  },
+}
+
+impl From<LidarrEditCommand> for Command {
+  fn from(value: LidarrEditCommand) -> Self {
+    Command::Lidarr(LidarrCommand::Edit(value))
+  }
+}
+
+pub(super) struct LidarrEditCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrEditCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrEditCommand> for LidarrEditCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrEditCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrEditCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrEditCommand::AllIndexerSettings {
+        maximum_size,
+        minimum_age,
+        retention,
+        rss_sync_interval,
+      } => {
+        if let Serdeable::Lidarr(LidarrSerdeable::IndexerSettings(previous_indexer_settings)) = self
+          .network
+          .handle_network_event(LidarrEvent::GetAllIndexerSettings.into())
+          .await?
+        {
+          let params = IndexerSettings {
+            id: 1,
+            maximum_size: maximum_size.unwrap_or(previous_indexer_settings.maximum_size),
+            minimum_age: minimum_age.unwrap_or(previous_indexer_settings.minimum_age),
+            retention: retention.unwrap_or(previous_indexer_settings.retention),
+            rss_sync_interval: rss_sync_interval
+              .unwrap_or(previous_indexer_settings.rss_sync_interval),
+          };
+          self
+            .network
+            .handle_network_event(LidarrEvent::EditAllIndexerSettings(params).into())
+            .await?;
+          "All indexer settings updated".to_owned()
+        } else {
+          String::new()
+        }
+      }
+      LidarrEditCommand::Artist {
+        artist_id,
+        enable_monitoring,
+        disable_monitoring,
+        monitor_new_items,
+        quality_profile_id,
+        metadata_profile_id,
+        root_folder_path,
+        tag,
+        clear_tags,
+      } => {
+        let monitored_value = mutex_flags_or_option(enable_monitoring, disable_monitoring);
+        let edit_artist_params = EditArtistParams {
+          artist_id,
+          monitored: monitored_value,
+          monitor_new_items,
+          quality_profile_id,
+          metadata_profile_id,
+          root_folder_path,
+          tags: tag,
+          tag_input_string: None,
+          clear_tags,
+        };
+
+        self
+          .network
+          .handle_network_event(LidarrEvent::EditArtist(edit_artist_params).into())
+          .await?;
+        "Artist Updated".to_owned()
+      }
+      LidarrEditCommand::Indexer {
+        indexer_id,
+        name,
+        enable_rss,
+        disable_rss,
+        enable_automatic_search,
+        disable_automatic_search,
+        enable_interactive_search,
+        disable_interactive_search,
+        url,
+        api_key,
+        seed_ratio,
+        tag,
+        priority,
+        clear_tags,
+      } => {
+        let rss_value = mutex_flags_or_option(enable_rss, disable_rss);
+        let automatic_search_value =
+          mutex_flags_or_option(enable_automatic_search, disable_automatic_search);
+        let interactive_search_value =
+          mutex_flags_or_option(enable_interactive_search, disable_interactive_search);
+        let edit_indexer_params = EditIndexerParams {
+          indexer_id,
+          name,
+          enable_rss: rss_value,
+          enable_automatic_search: automatic_search_value,
+          enable_interactive_search: interactive_search_value,
+          url,
+          api_key,
+          seed_ratio,
+          tags: tag,
+          tag_input_string: None,
+          priority,
+          clear_tags,
+        };
+
+        self
+          .network
+          .handle_network_event(LidarrEvent::EditIndexer(edit_indexer_params).into())
+          .await?;
+        "Indexer updated".to_owned()
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/edit_command_handler_tests.rs

@@ -0,0 +1,858 @@
+#[cfg(test)]
+mod tests {
+  use crate::cli::{
+    Command,
+    lidarr::{LidarrCommand, edit_command_handler::LidarrEditCommand},
+  };
+
+  #[test]
+  fn test_lidarr_edit_command_from() {
+    let command = LidarrEditCommand::Artist {
+      artist_id: 1,
+      enable_monitoring: false,
+      disable_monitoring: false,
+      monitor_new_items: None,
+      quality_profile_id: None,
+      metadata_profile_id: None,
+      root_folder_path: None,
+      tag: None,
+      clear_tags: false,
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::Edit(command)));
+  }
+
+  mod cli {
+    use crate::{Cli, models::lidarr_models::NewItemMonitorType};
+
+    use super::*;
+    use clap::{CommandFactory, Parser, error::ErrorKind};
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[test]
+    fn test_edit_all_indexer_settings_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "edit", "all-indexer-settings"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[rstest]
+    fn test_edit_all_indexer_settings_assert_argument_flags_require_args(
+      #[values(
+        "--maximum-size",
+        "--minimum-age",
+        "--retention",
+        "--rss-sync-interval"
+      )]
+      flag: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "all-indexer-settings",
+        flag,
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_all_indexer_settings_only_requires_at_least_one_argument() {
+      let expected_args = LidarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: None,
+        retention: None,
+        rss_sync_interval: None,
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "all-indexer-settings",
+        "--maximum-size",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_all_indexer_settings_all_arguments_defined() {
+      let expected_args = LidarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: Some(1),
+        retention: Some(1),
+        rss_sync_interval: Some(1),
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "all-indexer-settings",
+        "--maximum-size",
+        "1",
+        "--minimum-age",
+        "1",
+        "--retention",
+        "1",
+        "--rss-sync-interval",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_artist_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "edit", "artist"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_artist_with_artist_id_still_requires_arguments() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_artist_monitoring_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--enable-monitoring",
+        "--disable-monitoring",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_artist_tag_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--tag",
+        "1",
+        "--clear-tags",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[rstest]
+    fn test_edit_artist_assert_argument_flags_require_args(
+      #[values(
+        "--monitor-new-items",
+        "--quality-profile-id",
+        "--metadata-profile-id",
+        "--root-folder-path",
+        "--tag"
+      )]
+      flag: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        flag,
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_artist_monitor_new_items_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--monitor-new-items",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_artist_only_requires_at_least_one_argument_plus_artist_id() {
+      let expected_args = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        monitor_new_items: None,
+        quality_profile_id: None,
+        metadata_profile_id: None,
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: None,
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--root-folder-path",
+        "/nfs/test",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_artist_tag_argument_is_repeatable() {
+      let expected_args = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        monitor_new_items: None,
+        quality_profile_id: None,
+        metadata_profile_id: None,
+        root_folder_path: None,
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_artist_all_arguments_defined() {
+      let expected_args = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: true,
+        disable_monitoring: false,
+        monitor_new_items: Some(NewItemMonitorType::New),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "artist",
+        "--artist-id",
+        "1",
+        "--enable-monitoring",
+        "--monitor-new-items",
+        "new",
+        "--quality-profile-id",
+        "1",
+        "--metadata-profile-id",
+        "1",
+        "--root-folder-path",
+        "/nfs/test",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_indexer_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "edit", "indexer"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_indexer_with_indexer_id_still_requires_arguments() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_indexer_rss_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--enable-rss",
+        "--disable-rss",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_indexer_automatic_search_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--enable-automatic-search",
+        "--disable-automatic-search",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_indexer_interactive_search_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--enable-interactive-search",
+        "--disable-interactive-search",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_indexer_tag_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--tag",
+        "1",
+        "--clear-tags",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[rstest]
+    fn test_edit_indexer_assert_argument_flags_require_args(
+      #[values("--name", "--url", "--api-key", "--seed-ratio", "--tag", "--priority")] flag: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        flag,
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_indexer_only_requires_at_least_one_argument_plus_indexer_id() {
+      let expected_args = LidarrEditCommand::Indexer {
+        indexer_id: 1,
+        name: Some("Test".to_owned()),
+        enable_rss: false,
+        disable_rss: false,
+        enable_automatic_search: false,
+        disable_automatic_search: false,
+        enable_interactive_search: false,
+        disable_interactive_search: false,
+        url: None,
+        api_key: None,
+        seed_ratio: None,
+        tag: None,
+        priority: None,
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--name",
+        "Test",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_indexer_tag_argument_is_repeatable() {
+      let expected_args = LidarrEditCommand::Indexer {
+        indexer_id: 1,
+        name: None,
+        enable_rss: false,
+        disable_rss: false,
+        enable_automatic_search: false,
+        disable_automatic_search: false,
+        enable_interactive_search: false,
+        disable_interactive_search: false,
+        url: None,
+        api_key: None,
+        seed_ratio: None,
+        tag: Some(vec![1, 2]),
+        priority: None,
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_indexer_all_arguments_defined() {
+      let expected_args = LidarrEditCommand::Indexer {
+        indexer_id: 1,
+        name: Some("Test".to_owned()),
+        enable_rss: true,
+        disable_rss: false,
+        enable_automatic_search: true,
+        disable_automatic_search: false,
+        enable_interactive_search: true,
+        disable_interactive_search: false,
+        url: Some("http://test.com".to_owned()),
+        api_key: Some("testKey".to_owned()),
+        seed_ratio: Some("1.2".to_owned()),
+        tag: Some(vec![1, 2]),
+        priority: Some(25),
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--name",
+        "Test",
+        "--enable-rss",
+        "--enable-automatic-search",
+        "--enable-interactive-search",
+        "--url",
+        "http://test.com",
+        "--api-key",
+        "testKey",
+        "--seed-ratio",
+        "1.2",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+        "--priority",
+        "25",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::models::servarr_models::{EditIndexerParams, IndexerSettings};
+    use crate::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        lidarr::edit_command_handler::{LidarrEditCommand, LidarrEditCommandHandler},
+      },
+      models::{
+        Serdeable,
+        lidarr_models::{EditArtistParams, LidarrSerdeable, NewItemMonitorType},
+      },
+      network::{MockNetworkTrait, NetworkEvent, lidarr_network::LidarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_edit_all_indexer_settings_command() {
+      let expected_edit_all_indexer_settings = IndexerSettings {
+        id: 1,
+        maximum_size: 1,
+        minimum_age: 1,
+        retention: 1,
+        rss_sync_interval: 1,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::IndexerSettings(
+            IndexerSettings {
+              id: 1,
+              maximum_size: 2,
+              minimum_age: 2,
+              retention: 2,
+              rss_sync_interval: 2,
+            },
+          )))
+        });
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_all_indexer_settings_command = LidarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: Some(1),
+        retention: Some(1),
+        rss_sync_interval: Some(1),
+      };
+
+      let result = LidarrEditCommandHandler::with(
+        &app_arc,
+        edit_all_indexer_settings_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_artist_command() {
+      let expected_edit_artist_params = EditArtistParams {
+        artist_id: 1,
+        monitored: Some(true),
+        monitor_new_items: Some(NewItemMonitorType::New),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tags: Some(vec![1, 2]),
+        tag_input_string: None,
+        clear_tags: false,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditArtist(expected_edit_artist_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_artist_command = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: true,
+        disable_monitoring: false,
+        monitor_new_items: Some(NewItemMonitorType::New),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = LidarrEditCommandHandler::with(&app_arc, edit_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_artist_command_handles_disable_monitoring_flag_properly() {
+      let expected_edit_artist_params = EditArtistParams {
+        artist_id: 1,
+        monitored: Some(false),
+        monitor_new_items: Some(NewItemMonitorType::None),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tags: Some(vec![1, 2]),
+        tag_input_string: None,
+        clear_tags: false,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditArtist(expected_edit_artist_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_artist_command = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: true,
+        monitor_new_items: Some(NewItemMonitorType::None),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = LidarrEditCommandHandler::with(&app_arc, edit_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_artist_command_no_monitoring_boolean_flags_returns_none_value() {
+      let expected_edit_artist_params = EditArtistParams {
+        artist_id: 1,
+        monitored: None,
+        monitor_new_items: Some(NewItemMonitorType::All),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tags: Some(vec![1, 2]),
+        tag_input_string: None,
+        clear_tags: false,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditArtist(expected_edit_artist_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_artist_command = LidarrEditCommand::Artist {
+        artist_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        monitor_new_items: Some(NewItemMonitorType::All),
+        quality_profile_id: Some(1),
+        metadata_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = LidarrEditCommandHandler::with(&app_arc, edit_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_indexer_command() {
+      let expected_edit_indexer_params = EditIndexerParams {
+        indexer_id: 1,
+        name: Some("Test".to_owned()),
+        enable_rss: Some(true),
+        enable_automatic_search: Some(true),
+        enable_interactive_search: Some(true),
+        url: Some("http://test.com".to_owned()),
+        api_key: Some("testKey".to_owned()),
+        seed_ratio: Some("1.2".to_owned()),
+        tags: Some(vec![1, 2]),
+        tag_input_string: None,
+        priority: Some(25),
+        clear_tags: false,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditIndexer(expected_edit_indexer_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_indexer_command = LidarrEditCommand::Indexer {
+        indexer_id: 1,
+        name: Some("Test".to_owned()),
+        enable_rss: true,
+        disable_rss: false,
+        enable_automatic_search: true,
+        disable_automatic_search: false,
+        enable_interactive_search: true,
+        disable_interactive_search: false,
+        url: Some("http://test.com".to_owned()),
+        api_key: Some("testKey".to_owned()),
+        seed_ratio: Some("1.2".to_owned()),
+        tag: Some(vec![1, 2]),
+        priority: Some(25),
+        clear_tags: false,
+      };
+
+      let result =
+        LidarrEditCommandHandler::with(&app_arc, edit_indexer_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/get_command_handler.rs

@@ -0,0 +1,138 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+use super::LidarrCommand;
+
+#[cfg(test)]
+#[path = "get_command_handler_tests.rs"]
+mod get_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrGetCommand {
+  #[command(about = "Get detailed information for the album with the given ID")]
+  AlbumDetails {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the album whose details you wish to fetch",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(about = "Get the shared settings for all indexers")]
+  AllIndexerSettings,
+  #[command(about = "Get detailed information for the artist with the given ID")]
+  ArtistDetails {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist whose details you wish to fetch",
+      required = true
+    )]
+    artist_id: i64,
+  },
+  #[command(about = "Fetch the host config for your Lidarr instance")]
+  HostConfig,
+  #[command(about = "Fetch the security config for your Lidarr instance")]
+  SecurityConfig,
+  #[command(about = "Get the system status")]
+  SystemStatus,
+  #[command(about = "Get detailed information for the track with the given ID")]
+  TrackDetails {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the track whose details you wish to fetch",
+      required = true
+    )]
+    track_id: i64,
+  },
+}
+
+impl From<LidarrGetCommand> for Command {
+  fn from(value: LidarrGetCommand) -> Self {
+    Command::Lidarr(LidarrCommand::Get(value))
+  }
+}
+
+pub(super) struct LidarrGetCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrGetCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrGetCommand> for LidarrGetCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrGetCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrGetCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrGetCommand::AlbumDetails { album_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetAlbumDetails(album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::AllIndexerSettings => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetAllIndexerSettings.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::ArtistDetails { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetArtistDetails(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::HostConfig => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetHostConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::SecurityConfig => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetSecurityConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::SystemStatus => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetStatus.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrGetCommand::TrackDetails { track_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetTrackDetails(track_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/get_command_handler_tests.rs

@@ -0,0 +1,329 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    lidarr::{LidarrCommand, get_command_handler::LidarrGetCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_get_command_from() {
+    let command = LidarrGetCommand::SystemStatus;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::Get(command)));
+  }
+
+  mod cli {
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_album_details_requires_album_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "album-details"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_album_details_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "get",
+        "album-details",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_all_indexer_settings_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "all-indexer-settings"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_artist_details_requires_artist_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "artist-details"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_artist_details_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "get",
+        "artist-details",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_host_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "host-config"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_security_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "security-config"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_system_status_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "system-status"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_track_details_requires_track_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "get", "track-details"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_track_details_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "get",
+        "track-details",
+        "--track-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        lidarr::get_command_handler::{LidarrGetCommand, LidarrGetCommandHandler},
+      },
+      models::{Serdeable, lidarr_models::LidarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, lidarr_network::LidarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_get_album_details_command() {
+      let expected_album_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAlbumDetails(expected_album_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_album_details_command = LidarrGetCommand::AlbumDetails { album_id: 1 };
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_album_details_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_all_indexer_settings_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_all_indexer_settings_command = LidarrGetCommand::AllIndexerSettings;
+
+      let result = LidarrGetCommandHandler::with(
+        &app_arc,
+        get_all_indexer_settings_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_artist_details_command() {
+      let expected_artist_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetArtistDetails(expected_artist_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_artist_details_command = LidarrGetCommand::ArtistDetails { artist_id: 1 };
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_artist_details_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_host_config_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetHostConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_host_config_command = LidarrGetCommand::HostConfig;
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_host_config_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_security_config_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetSecurityConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_security_config_command = LidarrGetCommand::SecurityConfig;
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_security_config_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_system_status_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetStatus.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_system_status_command = LidarrGetCommand::SystemStatus;
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_system_status_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_track_details_command() {
+      let expected_track_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetTrackDetails(expected_track_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_track_details_command = LidarrGetCommand::TrackDetails { track_id: 1 };
+
+      let result =
+        LidarrGetCommandHandler::with(&app_arc, get_track_details_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/lidarr_command_tests.rs

@@ -0,0 +1,775 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    lidarr::{LidarrCommand, list_command_handler::LidarrListCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_command_from() {
+    let command = LidarrCommand::List(LidarrListCommand::Artists);
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(command));
+  }
+
+  mod cli {
+    use super::*;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[rstest]
+    fn test_commands_that_have_no_arg_requirements(
+      #[values("clear-blocklist", "test-all-indexers")] subcommand: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_list_artists_has_no_arg_requirements() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "artists"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_lidarr_list_subcommand_requires_subcommand() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "list"]);
+
+      assert_err!(&result);
+    }
+
+    #[test]
+    fn test_lidarr_add_subcommand_requires_subcommand() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "add"]);
+
+      assert_err!(&result);
+    }
+
+    #[test]
+    fn test_lidarr_delete_subcommand_requires_subcommand() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "delete"]);
+
+      assert_err!(&result);
+    }
+
+    #[test]
+    fn test_download_release_requires_guid() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "download-release",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_release_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "download-release",
+        "--guid",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_release_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "download-release",
+        "--guid",
+        "1",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_toggle_artist_monitoring_requires_artist_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "toggle-artist-monitoring"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_artist_monitoring_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "toggle-artist-monitoring",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_toggle_album_monitoring_requires_album_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "toggle-album-monitoring"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_album_monitoring_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "toggle-album-monitoring",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_search_new_artist_requires_query() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "search-new-artist"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_search_new_artist_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "search-new-artist",
+        "--query",
+        "test query",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_start_task_requires_task_name() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "start-task"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_start_task_task_name_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "start-task",
+        "--task-name",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_start_task_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "start-task",
+        "--task-name",
+        "application-update-check",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_mark_history_item_as_failed_requires_history_item_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "mark-history-item-as-failed"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_mark_history_item_as_failed_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "mark-history-item-as-failed",
+        "--history-item-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_test_indexer_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "test-indexer"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_test_indexer_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "test-indexer",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::cli::lidarr::add_command_handler::LidarrAddCommand;
+    use crate::cli::lidarr::edit_command_handler::LidarrEditCommand;
+    use crate::cli::lidarr::get_command_handler::LidarrGetCommand;
+    use crate::cli::lidarr::manual_search_command_handler::LidarrManualSearchCommand;
+    use crate::cli::lidarr::refresh_command_handler::LidarrRefreshCommand;
+    use crate::cli::lidarr::trigger_automatic_search_command_handler::LidarrTriggerAutomaticSearchCommand;
+    use crate::models::lidarr_models::{
+      BlocklistItem, BlocklistResponse, LidarrReleaseDownloadBody, LidarrTaskName,
+    };
+    use crate::models::servarr_models::IndexerSettings;
+    use crate::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        lidarr::{
+          LidarrCliHandler, LidarrCommand, delete_command_handler::LidarrDeleteCommand,
+          list_command_handler::LidarrListCommand,
+        },
+      },
+      models::{
+        Serdeable,
+        lidarr_models::{Artist, DeleteParams, LidarrSerdeable},
+      },
+      network::{MockNetworkTrait, NetworkEvent, lidarr_network::LidarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_add_commands_to_the_add_command_handler() {
+      let expected_tag_name = "test".to_owned();
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::AddTag(expected_tag_name.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_tag_command = LidarrCommand::Add(LidarrAddCommand::Tag {
+        name: expected_tag_name,
+      });
+
+      let result = LidarrCliHandler::with(&app_arc, add_tag_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_get_commands_to_the_get_command_handler() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetStatus.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_system_status_command = LidarrCommand::Get(LidarrGetCommand::SystemStatus);
+
+      let result = LidarrCliHandler::with(&app_arc, get_system_status_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_delete_commands_to_the_delete_command_handler() {
+      let expected_delete_artist_params = DeleteParams {
+        id: 1,
+        delete_files: true,
+        add_import_list_exclusion: true,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteArtist(expected_delete_artist_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_artist_command = LidarrCommand::Delete(LidarrDeleteCommand::Artist {
+        artist_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      });
+
+      let result = LidarrCliHandler::with(&app_arc, delete_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_edit_commands_to_the_edit_command_handler() {
+      let expected_edit_all_indexer_settings = IndexerSettings {
+        id: 1,
+        maximum_size: 1,
+        minimum_age: 1,
+        retention: 1,
+        rss_sync_interval: 1,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::IndexerSettings(
+            IndexerSettings {
+              id: 1,
+              maximum_size: 2,
+              minimum_age: 2,
+              retention: 2,
+              rss_sync_interval: 2,
+            },
+          )))
+        });
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_all_indexer_settings_command =
+        LidarrCommand::Edit(LidarrEditCommand::AllIndexerSettings {
+          maximum_size: Some(1),
+          minimum_age: Some(1),
+          retention: Some(1),
+          rss_sync_interval: Some(1),
+        });
+
+      let result = LidarrCliHandler::with(
+        &app_arc,
+        edit_all_indexer_settings_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_list_commands_to_the_list_command_handler() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::ListArtists.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Artists(vec![
+            Artist::default(),
+          ])))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_artists_command = LidarrCommand::List(LidarrListCommand::Artists);
+
+      let result = LidarrCliHandler::with(&app_arc, list_artists_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_refresh_commands_to_the_refresh_command_handler() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::UpdateAllArtists.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let refresh_artist_command = LidarrCommand::Refresh(LidarrRefreshCommand::AllArtists);
+
+      let result = LidarrCliHandler::with(&app_arc, refresh_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_manual_search_commands_to_the_manual_search_command_handler()
+     {
+      let expected_artist_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetDiscographyReleases(expected_artist_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_episode_search_command =
+        LidarrCommand::ManualSearch(LidarrManualSearchCommand::Discography { artist_id: 1 });
+
+      let result =
+        LidarrCliHandler::with(&app_arc, manual_episode_search_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_lidarr_cli_handler_delegates_trigger_automatic_search_commands_to_the_trigger_automatic_search_command_handler()
+     {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::TriggerAutomaticArtistSearch(1).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_search_command =
+        LidarrCommand::TriggerAutomaticSearch(LidarrTriggerAutomaticSearchCommand::Artist {
+          artist_id: 1,
+        });
+
+      let result = LidarrCliHandler::with(
+        &app_arc,
+        trigger_automatic_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_clear_blocklist_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::BlocklistResponse(
+            BlocklistResponse {
+              records: vec![BlocklistItem::default()],
+            },
+          )))
+        });
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::ClearBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let claer_blocklist_command = LidarrCommand::ClearBlocklist;
+
+      let result = LidarrCliHandler::with(&app_arc, claer_blocklist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_download_release_command() {
+      let expected_release_download_body = LidarrReleaseDownloadBody {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DownloadRelease(expected_release_download_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let download_release_command = LidarrCommand::DownloadRelease {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+      };
+
+      let result = LidarrCliHandler::with(&app_arc, download_release_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_toggle_artist_monitoring_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::ToggleArtistMonitoring(1).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let toggle_artist_monitoring_command = LidarrCommand::ToggleArtistMonitoring { artist_id: 1 };
+
+      let result = LidarrCliHandler::with(
+        &app_arc,
+        toggle_artist_monitoring_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_search_new_artist_command() {
+      let expected_query = "test artist".to_owned();
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::SearchNewArtist(expected_query.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let search_new_artist_command = LidarrCommand::SearchNewArtist {
+        query: expected_query,
+      };
+
+      let result = LidarrCliHandler::with(&app_arc, search_new_artist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_start_task_command() {
+      let expected_task_name = LidarrTaskName::ApplicationUpdateCheck;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::StartTask(expected_task_name).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let start_task_command = LidarrCommand::StartTask {
+        task_name: LidarrTaskName::ApplicationUpdateCheck,
+      };
+
+      let result = LidarrCliHandler::with(&app_arc, start_task_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_test_indexer_command() {
+      let expected_indexer_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::TestIndexer(expected_indexer_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let test_indexer_command = LidarrCommand::TestIndexer { indexer_id: 1 };
+
+      let result = LidarrCliHandler::with(&app_arc, test_indexer_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_test_all_indexers_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::TestAllIndexers.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let test_all_indexers_command = LidarrCommand::TestAllIndexers;
+
+      let result = LidarrCliHandler::with(&app_arc, test_all_indexers_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_mark_history_item_as_failed_command() {
+      let expected_history_item_id = 1i64;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::MarkHistoryItemAsFailed(expected_history_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let mark_history_item_as_failed_command = LidarrCommand::MarkHistoryItemAsFailed {
+        history_item_id: expected_history_item_id,
+      };
+
+      let result = LidarrCliHandler::with(
+        &app_arc,
+        mark_history_item_as_failed_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/list_command_handler.rs

@@ -0,0 +1,350 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use serde_json::json;
+use tokio::sync::Mutex;
+
+use super::LidarrCommand;
+use crate::models::Serdeable;
+use crate::models::lidarr_models::{LidarrHistoryItem, LidarrSerdeable};
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+#[cfg(test)]
+#[path = "list_command_handler_tests.rs"]
+mod list_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrListCommand {
+  #[command(about = "List all albums for the artist with the given ID")]
+  Albums {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist whose albums you want to list",
+      required = true
+    )]
+    artist_id: i64,
+  },
+  #[command(
+    about = "Fetch all history events for the given album corresponding to the artist with the given ID."
+  )]
+  AlbumHistory {
+    #[arg(
+      long,
+      help = "The Lidarr artist ID of the artist whose history you wish to fetch and list",
+      required = true
+    )]
+    artist_id: i64,
+    #[arg(
+      long,
+      help = "The Lidarr album ID to fetch history events for",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(about = "Fetch all history events for the artist with the given ID")]
+  ArtistHistory {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist whose history you wish to fetch",
+      required = true
+    )]
+    artist_id: i64,
+  },
+  #[command(about = "List all artists in your Lidarr library")]
+  Artists,
+  #[command(about = "List all items in the Lidarr blocklist")]
+  Blocklist,
+  #[command(about = "List disk space details for all provisioned root folders in Lidarr")]
+  DiskSpace,
+  #[command(about = "List all active downloads in Lidarr")]
+  Downloads {
+    #[arg(long, help = "How many downloads to fetch", default_value_t = 500)]
+    count: u64,
+  },
+  #[command(about = "Fetch all Lidarr history events")]
+  History {
+    #[arg(long, help = "How many history events to fetch", default_value_t = 500)]
+    events: u64,
+  },
+  #[command(about = "List all Lidarr indexers")]
+  Indexers,
+  #[command(about = "Fetch Lidarr logs")]
+  Logs {
+    #[arg(long, help = "How many log events to fetch", default_value_t = 500)]
+    events: u64,
+    #[arg(
+      long,
+      help = "Output the logs in the same format as they appear in the log files"
+    )]
+    output_in_log_format: bool,
+  },
+  #[command(about = "List all Lidarr metadata profiles")]
+  MetadataProfiles,
+  #[command(about = "List all Lidarr quality profiles")]
+  QualityProfiles,
+  #[command(about = "List all queued events")]
+  QueuedEvents,
+  #[command(about = "List all root folders in Lidarr")]
+  RootFolders,
+  #[command(about = "List all Lidarr tags")]
+  Tags,
+  #[command(about = "List all Lidarr tasks")]
+  Tasks,
+  #[command(about = "Fetch all history events for the track with the given ID")]
+  TrackHistory {
+    #[arg(
+      long,
+      help = "The artist ID that the track belongs to",
+      required = true
+    )]
+    artist_id: i64,
+    #[arg(
+      long,
+      help = "The album ID that the track is a part of",
+      required = true
+    )]
+    album_id: i64,
+    #[arg(
+      long,
+      help = "The Lidarr ID of the track whose history you wish to fetch",
+      required = true
+    )]
+    track_id: i64,
+  },
+  #[command(
+    about = "List the tracks for the album that corresponds to the artist with the given ID"
+  )]
+  Tracks {
+    #[arg(
+      long,
+      help = "The Lidarr artist ID of the artist whose tracks you wish to fetch",
+      required = true
+    )]
+    artist_id: i64,
+    #[arg(
+      long,
+      help = "The Lidarr album ID whose tracks you wish to fetch",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(about = "List the track files for the album with the given ID")]
+  TrackFiles {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the album whose track files you wish to fetch",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(about = "List all Lidarr updates")]
+  Updates,
+}
+
+impl From<LidarrListCommand> for Command {
+  fn from(value: LidarrListCommand) -> Self {
+    Command::Lidarr(LidarrCommand::List(value))
+  }
+}
+
+pub(super) struct LidarrListCommandHandler<'a, 'b> {
+  app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrListCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrListCommand> for LidarrListCommandHandler<'a, 'b> {
+  fn with(
+    app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrListCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrListCommandHandler {
+      app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrListCommand::Albums { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetAlbums(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::AlbumHistory {
+        artist_id,
+        album_id,
+      } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetAlbumHistory(artist_id, album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::ArtistHistory { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetArtistHistory(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Artists => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::ListArtists.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Blocklist => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::DiskSpace => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetDiskSpace.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Downloads { count } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetDownloads(count).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::History { events: items } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetHistory(items).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Indexers => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetIndexers.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Logs {
+        events,
+        output_in_log_format,
+      } => {
+        let logs = self
+          .network
+          .handle_network_event(LidarrEvent::GetLogs(events).into())
+          .await?;
+
+        if output_in_log_format {
+          let log_lines = &self.app.lock().await.data.sonarr_data.logs.items;
+
+          serde_json::to_string_pretty(log_lines)?
+        } else {
+          serde_json::to_string_pretty(&logs)?
+        }
+      }
+      LidarrListCommand::MetadataProfiles => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetMetadataProfiles.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::QualityProfiles => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetQualityProfiles.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::QueuedEvents => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetQueuedEvents.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::RootFolders => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetRootFolders.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Tags => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetTags.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Tasks => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetTasks.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::TrackHistory {
+        artist_id,
+        album_id,
+        track_id,
+      } => {
+        match self
+          .network
+          .handle_network_event(LidarrEvent::GetTrackHistory(artist_id, album_id, track_id).into())
+          .await
+        {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::LidarrHistoryItems(history_vec))) => {
+            let history_items_vec: Vec<LidarrHistoryItem> = history_vec
+              .into_iter()
+              .filter(|it| it.track_id == track_id)
+              .collect();
+            serde_json::to_string_pretty(&history_items_vec)?
+          }
+          Err(e) => return Err(e),
+          _ => serde_json::to_string_pretty(&json!({"message": "Failed to parse response"}))?,
+        }
+      }
+      LidarrListCommand::Tracks {
+        artist_id,
+        album_id,
+      } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetTracks(artist_id, album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::TrackFiles { album_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetTrackFiles(album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrListCommand::Updates => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetUpdates.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/list_command_handler_tests.rs

@@ -0,0 +1,728 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    lidarr::{LidarrCommand, list_command_handler::LidarrListCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_list_command_from() {
+    let command = LidarrListCommand::Artists;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::List(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use clap::{Parser, error::ErrorKind};
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[rstest]
+    fn test_list_commands_have_no_arg_requirements(
+      #[values(
+        "artists",
+        "blocklist",
+        "disk-space",
+        "indexers",
+        "metadata-profiles",
+        "quality-profiles",
+        "queued-events",
+        "tags",
+        "tasks",
+        "updates",
+        "root-folders"
+      )]
+      subcommand: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "list", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_list_albums_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "albums"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_albums_with_artist_id() {
+      let expected_args = LidarrListCommand::Albums { artist_id: 1 };
+      let result =
+        Cli::try_parse_from(["managarr", "lidarr", "list", "albums", "--artist-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(album_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(album_command, expected_args);
+    }
+
+    #[test]
+    fn test_album_history_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "album-history",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_album_history_requires_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "album-history",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_album_history_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "album-history",
+        "--artist-id",
+        "1",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_list_artist_history_requires_artist_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "artist-history"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_artist_history_success() {
+      let expected_args = LidarrListCommand::ArtistHistory { artist_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "artist-history",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(artist_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(artist_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_downloads_count_flag_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "downloads", "--count"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_downloads_default_values() {
+      let expected_args = LidarrListCommand::Downloads { count: 500 };
+      let result = Cli::try_parse_from(["managarr", "lidarr", "list", "downloads"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(downloads_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(downloads_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_history_events_flag_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "history", "--events"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_history_default_values() {
+      let expected_args = LidarrListCommand::History { events: 500 };
+      let result = Cli::try_parse_from(["managarr", "lidarr", "list", "history"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(history_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(history_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_logs_events_flag_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "logs", "--events"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_logs_default_values() {
+      let expected_args = LidarrListCommand::Logs {
+        events: 500,
+        output_in_log_format: false,
+      };
+      let result = Cli::try_parse_from(["managarr", "lidarr", "list", "logs"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(logs_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(logs_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_track_history_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "track-history",
+        "--album-id",
+        "1",
+        "--track-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_track_history_requires_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "track-history",
+        "--artist-id",
+        "1",
+        "--track-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_track_history_requires_track_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "track-history",
+        "--artist-id",
+        "1",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_track_history_success() {
+      let expected_args = LidarrListCommand::TrackHistory {
+        artist_id: 1,
+        album_id: 1,
+        track_id: 1,
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "track-history",
+        "--artist-id",
+        "1",
+        "--album-id",
+        "1",
+        "--track-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(track_history_command))) =
+        result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(track_history_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_tracks_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "tracks",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_tracks_requires_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "tracks",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_tracks_success() {
+      let expected_args = LidarrListCommand::Tracks {
+        artist_id: 1,
+        album_id: 1,
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "tracks",
+        "--artist-id",
+        "1",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(tracks_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(tracks_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_track_files_requires_album_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "list", "track-files"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_track_files_success() {
+      let expected_args = LidarrListCommand::TrackFiles { album_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "list",
+        "track-files",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::List(track_files_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(track_files_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use pretty_assertions::assert_str_eq;
+    use rstest::rstest;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::cli::CliCommandHandler;
+    use crate::cli::lidarr::list_command_handler::{LidarrListCommand, LidarrListCommandHandler};
+    use crate::models::Serdeable;
+    use crate::models::lidarr_models::{LidarrHistoryItem, LidarrSerdeable};
+    use crate::network::lidarr_network::LidarrEvent;
+    use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::lidarr_history_item;
+    use crate::{
+      app::App,
+      network::{MockNetworkTrait, NetworkEvent},
+    };
+
+    #[rstest]
+    #[case(LidarrListCommand::Artists, LidarrEvent::ListArtists)]
+    #[case(LidarrListCommand::Blocklist, LidarrEvent::GetBlocklist)]
+    #[case(LidarrListCommand::DiskSpace, LidarrEvent::GetDiskSpace)]
+    #[case(LidarrListCommand::Indexers, LidarrEvent::GetIndexers)]
+    #[case(LidarrListCommand::MetadataProfiles, LidarrEvent::GetMetadataProfiles)]
+    #[case(LidarrListCommand::QualityProfiles, LidarrEvent::GetQualityProfiles)]
+    #[case(LidarrListCommand::QueuedEvents, LidarrEvent::GetQueuedEvents)]
+    #[case(LidarrListCommand::RootFolders, LidarrEvent::GetRootFolders)]
+    #[case(LidarrListCommand::Tags, LidarrEvent::GetTags)]
+    #[case(LidarrListCommand::Tasks, LidarrEvent::GetTasks)]
+    #[case(LidarrListCommand::Updates, LidarrEvent::GetUpdates)]
+    #[tokio::test]
+    async fn test_handle_list_command(
+      #[case] list_command: LidarrListCommand,
+      #[case] expected_lidarr_event: LidarrEvent,
+    ) {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(expected_lidarr_event.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+
+      let result = LidarrListCommandHandler::with(&app_arc, list_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_albums_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetAlbums(1).into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_command = LidarrListCommand::Albums { artist_id: 1 };
+
+      let result = LidarrListCommandHandler::with(&app_arc, list_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_list_album_history_command() {
+      let expected_artist_id = 1;
+      let expected_album_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAlbumHistory(expected_artist_id, expected_album_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_album_history_command = LidarrListCommand::AlbumHistory {
+        artist_id: 1,
+        album_id: 1,
+      };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_album_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_artist_history_command() {
+      let expected_artist_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetArtistHistory(expected_artist_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_artist_history_command = LidarrListCommand::ArtistHistory { artist_id: 1 };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_artist_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_downloads_command() {
+      let expected_count = 1000;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetDownloads(expected_count).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_downloads_command = LidarrListCommand::Downloads { count: 1000 };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_downloads_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_history_command() {
+      let expected_events = 1000;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetHistory(expected_events).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_history_command = LidarrListCommand::History { events: 1000 };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_logs_command() {
+      let expected_events = 1000;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetLogs(expected_events).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_logs_command = LidarrListCommand::Logs {
+        events: 1000,
+        output_in_log_format: false,
+      };
+
+      let result = LidarrListCommandHandler::with(&app_arc, list_logs_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_track_history_command() {
+      let expected_artist_id = 1;
+      let expected_album_id = 1;
+      let expected_track_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetTrackHistory(expected_artist_id, expected_album_id, expected_track_id)
+            .into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::LidarrHistoryItems(
+            vec![
+              lidarr_history_item(),
+              LidarrHistoryItem {
+                track_id: 2,
+                ..lidarr_history_item()
+              },
+            ],
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_track_history_command = LidarrListCommand::TrackHistory {
+        artist_id: expected_artist_id,
+        album_id: expected_album_id,
+        track_id: expected_track_id,
+      };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_track_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+      assert_str_eq!(
+        result.unwrap(),
+        serde_json::to_string_pretty(&[lidarr_history_item()]).unwrap()
+      );
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_tracks_command() {
+      let expected_artist_id = 1;
+      let expected_album_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetTracks(expected_artist_id, expected_album_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_tracks_command = LidarrListCommand::Tracks {
+        artist_id: 1,
+        album_id: 1,
+      };
+
+      let result = LidarrListCommandHandler::with(&app_arc, list_tracks_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_track_files_command() {
+      let expected_album_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetTrackFiles(expected_album_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_track_files_command = LidarrListCommand::TrackFiles { album_id: 1 };
+
+      let result =
+        LidarrListCommandHandler::with(&app_arc, list_track_files_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/manual_search_command_handler.rs

@@ -0,0 +1,118 @@
+use crate::app::App;
+use crate::cli::lidarr::LidarrCommand;
+use crate::cli::{CliCommandHandler, Command};
+use crate::models::Serdeable;
+use crate::models::lidarr_models::{LidarrRelease, LidarrSerdeable};
+use crate::network::NetworkTrait;
+use crate::network::lidarr_network::LidarrEvent;
+use anyhow::Result;
+use clap::Subcommand;
+use serde_json::json;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+#[cfg(test)]
+#[path = "manual_search_command_handler_tests.rs"]
+mod manual_search_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrManualSearchCommand {
+  #[command(
+    about = "Trigger a manual search of releases for the given album corresponding to the artist with the given ID"
+  )]
+  Album {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist whose releases you wish to fetch and list",
+      required = true
+    )]
+    artist_id: i64,
+    #[arg(long, help = "The Lidarr album ID to search for", required = true)]
+    album_id: i64,
+  },
+  #[command(
+    about = "Trigger a manual search of discography releases for the given artist corresponding to the artist with the given ID."
+  )]
+  Discography {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist whose discography releases you wish to fetch and list",
+      required = true
+    )]
+    artist_id: i64,
+  },
+}
+
+impl From<LidarrManualSearchCommand> for Command {
+  fn from(value: LidarrManualSearchCommand) -> Self {
+    Command::Lidarr(LidarrCommand::ManualSearch(value))
+  }
+}
+
+pub(super) struct LidarrManualSearchCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrManualSearchCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrManualSearchCommand>
+  for LidarrManualSearchCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrManualSearchCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrManualSearchCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrManualSearchCommand::Album {
+        artist_id,
+        album_id,
+      } => {
+        println!("Searching for album releases. This may take a minute...");
+        match self
+          .network
+          .handle_network_event(LidarrEvent::GetAlbumReleases(artist_id, album_id).into())
+          .await
+        {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Releases(releases_vec))) => {
+            let albums_vec: Vec<LidarrRelease> = releases_vec
+              .into_iter()
+              .filter(|release| !release.discography)
+              .collect();
+            serde_json::to_string_pretty(&albums_vec)?
+          }
+          Err(e) => return Err(e),
+          _ => serde_json::to_string_pretty(&json!({"message": "Failed to parse response"}))?,
+        }
+      }
+      LidarrManualSearchCommand::Discography { artist_id } => {
+        println!("Searching for artist discography releases. This may take a minute...");
+        match self
+          .network
+          .handle_network_event(LidarrEvent::GetDiscographyReleases(artist_id).into())
+          .await
+        {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Releases(releases_vec))) => {
+            let discography_vec: Vec<LidarrRelease> = releases_vec
+              .into_iter()
+              .filter(|release| release.discography)
+              .collect();
+            serde_json::to_string_pretty(&discography_vec)?
+          }
+          Err(e) => return Err(e),
+          _ => serde_json::to_string_pretty(&json!({"message": "Failed to parse response"}))?,
+        }
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/manual_search_command_handler_tests.rs

@@ -0,0 +1,207 @@
+#[cfg(test)]
+mod tests {
+  use crate::cli::Command;
+  use crate::cli::lidarr::LidarrCommand;
+  use crate::cli::lidarr::manual_search_command_handler::LidarrManualSearchCommand;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_lidarr_manual_search_command_from() {
+    let command = LidarrManualSearchCommand::Discography { artist_id: 1 };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(
+      result,
+      Command::Lidarr(LidarrCommand::ManualSearch(command))
+    );
+  }
+
+  mod cli {
+    use crate::Cli;
+    use clap::CommandFactory;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_manual_album_search_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "manual-search",
+        "album",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_album_search_requires_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "manual-search",
+        "album",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_album_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "manual-search",
+        "album",
+        "--artist-id",
+        "1",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_manual_discography_search_requires_artist_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "manual-search", "discography"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_discography_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "manual-search",
+        "discography",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+  }
+
+  mod handler {
+    use crate::app::App;
+    use crate::cli::CliCommandHandler;
+    use crate::cli::lidarr::manual_search_command_handler::{
+      LidarrManualSearchCommand, LidarrManualSearchCommandHandler,
+    };
+    use crate::models::Serdeable;
+    use crate::models::lidarr_models::{LidarrRelease, LidarrSerdeable};
+    use crate::network::lidarr_network::LidarrEvent;
+    use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::{
+      torrent_release, usenet_release,
+    };
+    use crate::network::{MockNetworkTrait, NetworkEvent};
+    use mockall::predicate::eq;
+    use pretty_assertions::assert_str_eq;
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+
+    #[tokio::test]
+    async fn test_manual_album_search_command() {
+      let expected_releases = [torrent_release()];
+      let expected_artist_id = 1;
+      let expected_album_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetAlbumReleases(expected_artist_id, expected_album_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Releases(vec![
+            torrent_release(),
+            LidarrRelease {
+              discography: true,
+              ..usenet_release()
+            },
+          ])))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_album_search_command = LidarrManualSearchCommand::Album {
+        artist_id: 1,
+        album_id: 1,
+      };
+
+      let result = LidarrManualSearchCommandHandler::with(
+        &app_arc,
+        manual_album_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+      assert_str_eq!(
+        result.unwrap(),
+        serde_json::to_string_pretty(&expected_releases).unwrap()
+      );
+    }
+
+    #[tokio::test]
+    async fn test_manual_discography_search_command() {
+      let expected_releases = [LidarrRelease {
+        discography: true,
+        ..usenet_release()
+      }];
+      let expected_artist_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::GetDiscographyReleases(expected_artist_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Releases(vec![
+            torrent_release(),
+            LidarrRelease {
+              discography: true,
+              ..usenet_release()
+            },
+          ])))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_discography_search_command =
+        LidarrManualSearchCommand::Discography { artist_id: 1 };
+
+      let result = LidarrManualSearchCommandHandler::with(
+        &app_arc,
+        manual_discography_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+      assert_str_eq!(
+        result.unwrap(),
+        serde_json::to_string_pretty(&expected_releases).unwrap()
+      );
+    }
+  }
+}

src/cli/lidarr/mod.rs

@@ -0,0 +1,295 @@
+use std::sync::Arc;
+
+use add_command_handler::{LidarrAddCommand, LidarrAddCommandHandler};
+use anyhow::Result;
+use clap::Subcommand;
+use delete_command_handler::{LidarrDeleteCommand, LidarrDeleteCommandHandler};
+use edit_command_handler::{LidarrEditCommand, LidarrEditCommandHandler};
+use get_command_handler::{LidarrGetCommand, LidarrGetCommandHandler};
+use list_command_handler::{LidarrListCommand, LidarrListCommandHandler};
+use refresh_command_handler::{LidarrRefreshCommand, LidarrRefreshCommandHandler};
+use serde_json::json;
+use tokio::sync::Mutex;
+use trigger_automatic_search_command_handler::{
+  LidarrTriggerAutomaticSearchCommand, LidarrTriggerAutomaticSearchCommandHandler,
+};
+
+use super::{CliCommandHandler, Command};
+use crate::cli::lidarr::manual_search_command_handler::{
+  LidarrManualSearchCommand, LidarrManualSearchCommandHandler,
+};
+use crate::models::lidarr_models::{LidarrReleaseDownloadBody, LidarrTaskName};
+use crate::network::lidarr_network::LidarrEvent;
+use crate::{app::App, network::NetworkTrait};
+
+mod add_command_handler;
+mod delete_command_handler;
+mod edit_command_handler;
+mod get_command_handler;
+mod list_command_handler;
+mod manual_search_command_handler;
+mod refresh_command_handler;
+mod trigger_automatic_search_command_handler;
+
+#[cfg(test)]
+#[path = "lidarr_command_tests.rs"]
+mod lidarr_command_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrCommand {
+  #[command(
+    subcommand,
+    about = "Commands to add or create new resources within your Lidarr instance"
+  )]
+  Add(LidarrAddCommand),
+  #[command(
+    subcommand,
+    about = "Commands to delete resources from your Lidarr instance"
+  )]
+  Delete(LidarrDeleteCommand),
+  #[command(
+    subcommand,
+    about = "Commands to edit resources in your Lidarr instance"
+  )]
+  Edit(LidarrEditCommand),
+  #[command(
+    subcommand,
+    about = "Commands to fetch details of the resources in your Lidarr instance"
+  )]
+  Get(LidarrGetCommand),
+  #[command(
+    subcommand,
+    about = "Commands to list attributes from your Lidarr instance"
+  )]
+  List(LidarrListCommand),
+  #[command(
+    subcommand,
+    about = "Commands to refresh the data in your Lidarr instance"
+  )]
+  Refresh(LidarrRefreshCommand),
+  #[command(subcommand, about = "Commands to manually search for releases")]
+  ManualSearch(LidarrManualSearchCommand),
+  #[command(
+    subcommand,
+    about = "Commands to trigger automatic searches for releases of different resources in your Lidarr instance"
+  )]
+  TriggerAutomaticSearch(LidarrTriggerAutomaticSearchCommand),
+  #[command(about = "Clear the Lidarr blocklist")]
+  ClearBlocklist,
+  #[command(about = "Manually download the given release")]
+  DownloadRelease {
+    #[arg(long, help = "The GUID of the release to download", required = true)]
+    guid: String,
+    #[arg(
+      long,
+      help = "The indexer ID to download the release from",
+      required = true
+    )]
+    indexer_id: i64,
+  },
+  #[command(about = "Mark the Lidarr history item with the given ID as 'failed'")]
+  MarkHistoryItemAsFailed {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the history item you wish to mark as 'failed'",
+      required = true
+    )]
+    history_item_id: i64,
+  },
+  #[command(about = "Search for a new artist to add to Lidarr")]
+  SearchNewArtist {
+    #[arg(
+      long,
+      help = "The name of the artist you want to search for",
+      required = true
+    )]
+    query: String,
+  },
+  #[command(about = "Start the specified Lidarr task")]
+  StartTask {
+    #[arg(
+      long,
+      help = "The name of the task to trigger",
+      value_enum,
+      required = true
+    )]
+    task_name: LidarrTaskName,
+  },
+  #[command(
+    about = "Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'"
+  )]
+  TestIndexer {
+    #[arg(long, help = "The ID of the indexer to test", required = true)]
+    indexer_id: i64,
+  },
+  #[command(about = "Test all Lidarr indexers")]
+  TestAllIndexers,
+  #[command(
+    about = "Toggle monitoring for the specified album corresponding to the given album ID"
+  )]
+  ToggleAlbumMonitoring {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the album to toggle monitoring on",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(
+    about = "Toggle monitoring for the specified artist corresponding to the given artist ID"
+  )]
+  ToggleArtistMonitoring {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the artist to toggle monitoring on",
+      required = true
+    )]
+    artist_id: i64,
+  },
+}
+
+impl From<LidarrCommand> for Command {
+  fn from(lidarr_command: LidarrCommand) -> Command {
+    Command::Lidarr(lidarr_command)
+  }
+}
+
+pub(super) struct LidarrCliHandler<'a, 'b> {
+  app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrCommand> for LidarrCliHandler<'a, 'b> {
+  fn with(
+    app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrCliHandler {
+      app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrCommand::Add(add_command) => {
+        LidarrAddCommandHandler::with(self.app, add_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::Delete(delete_command) => {
+        LidarrDeleteCommandHandler::with(self.app, delete_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::Edit(edit_command) => {
+        LidarrEditCommandHandler::with(self.app, edit_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::Get(get_command) => {
+        LidarrGetCommandHandler::with(self.app, get_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::List(list_command) => {
+        LidarrListCommandHandler::with(self.app, list_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::Refresh(refresh_command) => {
+        LidarrRefreshCommandHandler::with(self.app, refresh_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::ManualSearch(manual_search_command) => {
+        LidarrManualSearchCommandHandler::with(self.app, manual_search_command, self.network)
+          .handle()
+          .await?
+      }
+      LidarrCommand::TriggerAutomaticSearch(trigger_automatic_search_command) => {
+        LidarrTriggerAutomaticSearchCommandHandler::with(
+          self.app,
+          trigger_automatic_search_command,
+          self.network,
+        )
+        .handle()
+        .await?
+      }
+      LidarrCommand::ClearBlocklist => {
+        self
+          .network
+          .handle_network_event(LidarrEvent::GetBlocklist.into())
+          .await?;
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::ClearBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::DownloadRelease { guid, indexer_id } => {
+        let params = LidarrReleaseDownloadBody { guid, indexer_id };
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DownloadRelease(params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::MarkHistoryItemAsFailed { history_item_id } => {
+        let _ = self
+          .network
+          .handle_network_event(LidarrEvent::MarkHistoryItemAsFailed(history_item_id).into())
+          .await?;
+        serde_json::to_string_pretty(&json!({"message": "Lidarr history item marked as 'failed'"}))?
+      }
+      LidarrCommand::SearchNewArtist { query } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::SearchNewArtist(query).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::StartTask { task_name } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::StartTask(task_name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::TestIndexer { indexer_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::TestIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::TestAllIndexers => {
+        println!("Testing all Lidarr indexers. This may take a minute...");
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::TestAllIndexers.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::ToggleAlbumMonitoring { album_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::ToggleAlbumMonitoring(album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrCommand::ToggleArtistMonitoring { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::ToggleArtistMonitoring(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/refresh_command_handler.rs

@@ -0,0 +1,89 @@
+use std::sync::Arc;
+
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+use super::LidarrCommand;
+
+#[cfg(test)]
+#[path = "refresh_command_handler_tests.rs"]
+mod refresh_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrRefreshCommand {
+  #[command(about = "Refresh all artist data for all artists in your Lidarr library")]
+  AllArtists,
+  #[command(about = "Refresh artist data and scan disk for the artist with the given ID")]
+  Artist {
+    #[arg(
+      long,
+      help = "The ID of the artist to refresh information on and to scan the disk for",
+      required = true
+    )]
+    artist_id: i64,
+  },
+  #[command(about = "Refresh all downloads in Lidarr")]
+  Downloads,
+}
+
+impl From<LidarrRefreshCommand> for Command {
+  fn from(value: LidarrRefreshCommand) -> Self {
+    Command::Lidarr(LidarrCommand::Refresh(value))
+  }
+}
+
+pub(super) struct LidarrRefreshCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrRefreshCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrRefreshCommand>
+  for LidarrRefreshCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrRefreshCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrRefreshCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> anyhow::Result<String> {
+    let result = match self.command {
+      LidarrRefreshCommand::AllArtists => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::UpdateAllArtists.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrRefreshCommand::Artist { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::UpdateAndScanArtist(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrRefreshCommand::Downloads => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::UpdateDownloads.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/refresh_command_handler_tests.rs

@@ -0,0 +1,138 @@
+#[cfg(test)]
+mod tests {
+  use pretty_assertions::assert_eq;
+
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    lidarr::{LidarrCommand, refresh_command_handler::LidarrRefreshCommand},
+  };
+  use clap::CommandFactory;
+
+  #[test]
+  fn test_lidarr_refresh_command_from() {
+    let command = LidarrRefreshCommand::AllArtists;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Lidarr(LidarrCommand::Refresh(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use clap::{Parser, error::ErrorKind};
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[rstest]
+    fn test_refresh_commands_have_no_arg_requirements(
+      #[values("all-artists", "downloads")] subcommand: &str,
+    ) {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "refresh", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_refresh_artist_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "lidarr", "refresh", "artist"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_refresh_artist_with_artist_id() {
+      let expected_args = LidarrRefreshCommand::Artist { artist_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "refresh",
+        "artist",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+      let Some(Command::Lidarr(LidarrCommand::Refresh(refresh_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(refresh_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use rstest::rstest;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::{app::App, cli::lidarr::refresh_command_handler::LidarrRefreshCommandHandler};
+    use crate::{
+      cli::{CliCommandHandler, lidarr::refresh_command_handler::LidarrRefreshCommand},
+      network::lidarr_network::LidarrEvent,
+    };
+    use crate::{
+      models::{Serdeable, lidarr_models::LidarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent},
+    };
+
+    #[rstest]
+    #[case(LidarrRefreshCommand::AllArtists, LidarrEvent::UpdateAllArtists)]
+    #[case(LidarrRefreshCommand::Downloads, LidarrEvent::UpdateDownloads)]
+    #[tokio::test]
+    async fn test_handle_refresh_command(
+      #[case] refresh_command: LidarrRefreshCommand,
+      #[case] expected_sonarr_event: LidarrEvent,
+    ) {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(expected_sonarr_event.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+
+      let result = LidarrRefreshCommandHandler::with(&app_arc, refresh_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_refresh_artist_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::UpdateAndScanArtist(1).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let refresh_command = LidarrRefreshCommand::Artist { artist_id: 1 };
+
+      let result = LidarrRefreshCommandHandler::with(&app_arc, refresh_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/lidarr/trigger_automatic_search_command_handler.rs

@@ -0,0 +1,88 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, lidarr_network::LidarrEvent},
+};
+
+use super::LidarrCommand;
+
+#[cfg(test)]
+#[path = "trigger_automatic_search_command_handler_tests.rs"]
+mod trigger_automatic_search_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum LidarrTriggerAutomaticSearchCommand {
+  #[command(about = "Trigger an automatic search for the album with the specified ID")]
+  Album {
+    #[arg(
+      long,
+      help = "The Lidarr ID of the album you want to trigger an automatic search for",
+      required = true
+    )]
+    album_id: i64,
+  },
+  #[command(about = "Trigger an automatic search for the artist with the specified ID")]
+  Artist {
+    #[arg(
+      long,
+      help = "The ID of the artist you want to trigger an automatic search for",
+      required = true
+    )]
+    artist_id: i64,
+  },
+}
+
+impl From<LidarrTriggerAutomaticSearchCommand> for Command {
+  fn from(value: LidarrTriggerAutomaticSearchCommand) -> Self {
+    Command::Lidarr(LidarrCommand::TriggerAutomaticSearch(value))
+  }
+}
+
+pub(super) struct LidarrTriggerAutomaticSearchCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: LidarrTriggerAutomaticSearchCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrTriggerAutomaticSearchCommand>
+  for LidarrTriggerAutomaticSearchCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: LidarrTriggerAutomaticSearchCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    LidarrTriggerAutomaticSearchCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      LidarrTriggerAutomaticSearchCommand::Album { album_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::TriggerAutomaticAlbumSearch(album_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      LidarrTriggerAutomaticSearchCommand::Artist { artist_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::TriggerAutomaticArtistSearch(artist_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/lidarr/trigger_automatic_search_command_handler_tests.rs

@@ -0,0 +1,166 @@
+#[cfg(test)]
+mod tests {
+  use pretty_assertions::assert_eq;
+
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    lidarr::{
+      LidarrCommand, trigger_automatic_search_command_handler::LidarrTriggerAutomaticSearchCommand,
+    },
+  };
+  use clap::CommandFactory;
+
+  #[test]
+  fn test_lidarr_trigger_automatic_search_command_from() {
+    let command = LidarrTriggerAutomaticSearchCommand::Artist { artist_id: 1 };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(
+      result,
+      Command::Lidarr(LidarrCommand::TriggerAutomaticSearch(command))
+    );
+  }
+
+  mod cli {
+    use super::*;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_trigger_automatic_album_search_requires_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "trigger-automatic-search",
+        "album",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_album_search_with_album_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "trigger-automatic-search",
+        "album",
+        "--album-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_trigger_automatic_artist_search_requires_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "trigger-automatic-search",
+        "artist",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_artist_search_with_artist_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "lidarr",
+        "trigger-automatic-search",
+        "artist",
+        "--artist-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+  }
+
+  mod handler {
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::cli::lidarr::trigger_automatic_search_command_handler::{
+      LidarrTriggerAutomaticSearchCommand, LidarrTriggerAutomaticSearchCommandHandler,
+    };
+    use crate::{app::App, cli::CliCommandHandler};
+    use crate::{
+      models::{Serdeable, lidarr_models::LidarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, lidarr_network::LidarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_trigger_automatic_album_search_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::TriggerAutomaticAlbumSearch(1).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_search_command =
+        LidarrTriggerAutomaticSearchCommand::Album { album_id: 1 };
+
+      let result = LidarrTriggerAutomaticSearchCommandHandler::with(
+        &app_arc,
+        trigger_automatic_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_trigger_automatic_artist_search_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::TriggerAutomaticArtistSearch(1).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_search_command =
+        LidarrTriggerAutomaticSearchCommand::Artist { artist_id: 1 };
+
+      let result = LidarrTriggerAutomaticSearchCommandHandler::with(
+        &app_arc,
+        trigger_automatic_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/mod.rs

@@ -1,14 +1,19 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use clap::{command, Subcommand};
+use clap::Subcommand;
 use clap_complete::Shell;
+use indoc::indoc;
+use lidarr::{LidarrCliHandler, LidarrCommand};
 use radarr::{RadarrCliHandler, RadarrCommand};
+use sonarr::{SonarrCliHandler, SonarrCommand};
 use tokio::sync::Mutex;
 
 use crate::{app::App, network::NetworkTrait};
 
+pub mod lidarr;
 pub mod radarr;
+pub mod sonarr;
 
 #[cfg(test)]
 #[path = "cli_tests.rs"]
@@ -19,6 +24,12 @@ pub enum Command {
   #[command(subcommand, about = "Commands for manging your Radarr instance")]
   Radarr(RadarrCommand),
 
+  #[command(subcommand, about = "Commands for manging your Sonarr instance")]
+  Sonarr(SonarrCommand),
+
+  #[command(subcommand, about = "Commands for manging your Lidarr instance")]
+  Lidarr(LidarrCommand),
+
   #[command(
     arg_required_else_help = true,
     about = "Generate shell completions for the Managarr CLI"
@@ -27,24 +38,50 @@ pub enum Command {
     #[arg(value_enum)]
     shell: Shell,
   },
+
+  #[command(about = "Tail Managarr logs")]
+  TailLogs {
+    #[arg(long, help = "Disable colored log output")]
+    no_color: bool,
+  },
+
+  #[command(about = indoc!{"
+      Print the full path to the default configuration file.
+      This file can be changed to another location using the '--config-file' flag
+    "})]
+  ConfigPath,
 }
 
 pub trait CliCommandHandler<'a, 'b, T: Into<Command>> {
   fn with(app: &'a Arc<Mutex<App<'b>>>, command: T, network: &'a mut dyn NetworkTrait) -> Self;
-  async fn handle(self) -> Result<()>;
+  async fn handle(self) -> Result<String>;
 }
 
 pub(crate) async fn handle_command(
   app: &Arc<Mutex<App<'_>>>,
   command: Command,
   network: &mut dyn NetworkTrait,
-) -> Result<()> {
+) -> Result<String> {
-  if let Command::Radarr(radarr_command) = command {
+  let result = match command {
-    RadarrCliHandler::with(app, radarr_command, network)
+    Command::Radarr(radarr_command) => {
-      .handle()
+      RadarrCliHandler::with(app, radarr_command, network)
-      .await?
+        .handle()
-  }
+        .await?
-  Ok(())
+    }
+    Command::Sonarr(sonarr_command) => {
+      SonarrCliHandler::with(app, sonarr_command, network)
+        .handle()
+        .await?
+    }
+    Command::Lidarr(lidarr_command) => {
+      LidarrCliHandler::with(app, lidarr_command, network)
+        .handle()
+        .await?
+    }
+    _ => String::new(),
+  };
+
+  Ok(result)
 }
 
 #[inline]
@@ -68,16 +105,3 @@ pub fn mutex_flags_or_default(positive: bool, negative: bool, default_value: boo
     default_value
   }
 }
-
-#[macro_export]
-macro_rules! execute_network_event {
-  ($self:ident, $event:expr) => {
-    let resp = $self.network.handle_network_event($event.into()).await?;
-    let json = serde_json::to_string_pretty(&resp)?;
-    println!("{}", json);
-  };
-  ($self:ident, $event:expr, $happy_output:expr) => {
-    $self.network.handle_network_event($event.into()).await?;
-    println!("{}", $happy_output);
-  };
-}

src/cli/radarr/add_command_handler.rs

@@ -1,19 +1,18 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use clap::{arg, command, ArgAction, Subcommand};
+use clap::{ArgAction, Subcommand};
 use tokio::sync::Mutex;
 
+use super::RadarrCommand;
+use crate::models::servarr_models::AddRootFolderBody;
 use crate::{
   app::App,
   cli::{CliCommandHandler, Command},
-  execute_network_event,
+  models::radarr_models::{AddMovieBody, AddMovieOptions, MinimumAvailability, MovieMonitor},
-  models::radarr_models::{AddMovieBody, AddOptions, MinimumAvailability, Monitor},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
-  network::{radarr_network::RadarrEvent, NetworkTrait},
 };
 
-use super::RadarrCommand;
-
 #[cfg(test)]
 #[path = "add_command_handler_tests.rs"]
 mod add_command_handler_tests;
@@ -47,7 +46,7 @@ pub enum RadarrAddCommand {
       default_value_t = MinimumAvailability::default()
     )]
     minimum_availability: MinimumAvailability,
-    #[arg(long, help = "Should Radarr monitor this film")]
+    #[arg(long, help = "Disable monitoring for this film")]
     disable_monitoring: bool,
     #[arg(
       long,
@@ -60,9 +59,9 @@ pub enum RadarrAddCommand {
       long,
       help = "What Radarr should monitor", 
       value_enum,
-      default_value_t = Monitor::default()
+      default_value_t = MovieMonitor::default()
     )]
-    monitor: Monitor,
+    monitor: MovieMonitor,
     #[arg(
       long,
       help = "Tell Radarr to not start a search for this film once it's added to your library"
@@ -106,8 +105,8 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrAddCommand> for RadarrAddCommandHan
     }
   }
 
-  async fn handle(self) -> Result<()> {
+  async fn handle(self) -> Result<String> {
-    match self.command {
+    let result = match self.command {
       RadarrAddCommand::Movie {
         tmdb_id,
         root_folder_path,
@@ -123,27 +122,40 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrAddCommand> for RadarrAddCommandHan
           title: String::new(),
           root_folder_path,
           quality_profile_id,
-          minimum_availability: minimum_availability.to_string(),
+          minimum_availability,
           monitored: !disable_monitoring,
           tags,
-          add_options: AddOptions {
+          tag_input_string: None,
-            monitor: monitor.to_string(),
+          add_options: AddMovieOptions {
+            monitor,
             search_for_movie: !no_search_for_movie,
           },
         };
-        execute_network_event!(self, RadarrEvent::AddMovie(Some(body)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::AddMovie(body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrAddCommand::RootFolder { root_folder_path } => {
-        execute_network_event!(
+        let add_root_folder_body = AddRootFolderBody {
-          self,
+          path: root_folder_path,
-          RadarrEvent::AddRootFolder(Some(root_folder_path.clone()))
+        };
-        );
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::AddRootFolder(add_root_folder_body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrAddCommand::Tag { name } => {
-        execute_network_event!(self, RadarrEvent::AddTag(name.clone()));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::AddTag(name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/add_command_handler_tests.rs

@@ -1,15 +1,16 @@
 #[cfg(test)]
 mod tests {
-  use clap::{error::ErrorKind, CommandFactory, Parser};
+  use clap::{CommandFactory, Parser, error::ErrorKind};
 
   use crate::{
-    cli::{
-      radarr::{add_command_handler::RadarrAddCommand, RadarrCommand},
-      Command,
-    },
-    models::radarr_models::{MinimumAvailability, Monitor},
     Cli,
+    cli::{
+      Command,
+      radarr::{RadarrCommand, add_command_handler::RadarrAddCommand},
+    },
+    models::radarr_models::{MinimumAvailability, MovieMonitor},
   };
+  use pretty_assertions::assert_eq;
 
   #[test]
   fn test_radarr_add_command_from() {
@@ -31,7 +32,7 @@ mod tests {
     fn test_add_movie_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "add", "movie"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -51,7 +52,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -71,7 +72,7 @@ mod tests {
         "/test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -91,7 +92,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -111,10 +112,12 @@ mod tests {
         "/test",
         "--quality-profile-id",
         "1",
+        "--tmdb-id",
+        "1",
         flag,
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -133,7 +136,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -153,7 +156,7 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -174,7 +177,7 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -187,7 +190,7 @@ mod tests {
         minimum_availability: MinimumAvailability::default(),
         disable_monitoring: false,
         tag: vec![],
-        monitor: Monitor::default(),
+        monitor: MovieMonitor::default(),
         no_search_for_movie: false,
       };
 
@@ -204,10 +207,11 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command else {
-        assert_eq!(add_command, expected_args);
+        panic!("Unexpected command type")
-      }
+      };
+      assert_eq!(add_command, expected_args);
     }
 
     #[test]
@@ -219,7 +223,7 @@ mod tests {
         minimum_availability: MinimumAvailability::default(),
         disable_monitoring: false,
         tag: vec![1, 2],
-        monitor: Monitor::default(),
+        monitor: MovieMonitor::default(),
         no_search_for_movie: false,
       };
 
@@ -240,10 +244,11 @@ mod tests {
         "2",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command else {
-        assert_eq!(add_command, expected_args);
+        panic!("Unexpected command type")
-      }
+      };
+      assert_eq!(add_command, expected_args);
     }
 
     #[test]
@@ -255,7 +260,7 @@ mod tests {
         minimum_availability: MinimumAvailability::Released,
         disable_monitoring: true,
         tag: vec![1, 2],
-        monitor: Monitor::MovieAndCollection,
+        monitor: MovieMonitor::MovieAndCollection,
         no_search_for_movie: true,
       };
 
@@ -282,10 +287,11 @@ mod tests {
         "--no-search-for-movie",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command else {
-        assert_eq!(add_command, expected_args);
+        panic!("Unexpected command type")
-      }
+      };
+      assert_eq!(add_command, expected_args);
     }
 
     #[test]
@@ -293,7 +299,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "add", "root-folder"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -315,18 +321,19 @@ mod tests {
         "/nfs/test",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command else {
-        assert_eq!(add_command, expected_args);
+        panic!("Unexpected command type")
-      }
+      };
+      assert_eq!(add_command, expected_args);
     }
 
     #[test]
     fn test_add_tag_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "add", "tag"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -341,11 +348,12 @@ mod tests {
 
       let result = Cli::try_parse_from(["managarr", "radarr", "add", "tag", "--name", "test"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Add(add_command))) = result.unwrap().command else {
-        assert_eq!(add_command, expected_args);
+        panic!("Unexpected command type")
-      }
+      };
+      assert_eq!(add_command, expected_args);
     }
   }
 
@@ -354,17 +362,18 @@ mod tests {
 
     use crate::{
       app::App,
-      cli::{radarr::add_command_handler::RadarrAddCommandHandler, CliCommandHandler},
+      cli::{CliCommandHandler, radarr::add_command_handler::RadarrAddCommandHandler},
       models::{
-        radarr_models::{AddMovieBody, AddOptions, RadarrSerdeable},
         Serdeable,
+        radarr_models::{AddMovieBody, AddMovieOptions, RadarrSerdeable},
       },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     use super::*;
     use mockall::predicate::eq;
 
+    use crate::models::servarr_models::AddRootFolderBody;
     use serde_json::json;
     use tokio::sync::Mutex;
 
@@ -375,11 +384,12 @@ mod tests {
         title: String::new(),
         root_folder_path: "/test".to_owned(),
         quality_profile_id: 1,
-        minimum_availability: "released".to_owned(),
+        minimum_availability: MinimumAvailability::Released,
         monitored: false,
         tags: vec![1, 2],
-        add_options: AddOptions {
+        tag_input_string: None,
-          monitor: "movieAndCollection".to_owned(),
+        add_options: AddMovieOptions {
+          monitor: MovieMonitor::MovieAndCollection,
           search_for_movie: false,
         },
       };
@@ -387,7 +397,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::AddMovie(Some(expected_add_movie_body)).into(),
+          RadarrEvent::AddMovie(expected_add_movie_body).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -395,7 +405,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let add_movie_command = RadarrAddCommand::Movie {
         tmdb_id: 1,
         root_folder_path: "/test".to_owned(),
@@ -403,7 +413,7 @@ mod tests {
         minimum_availability: MinimumAvailability::Released,
         disable_monitoring: true,
         tag: vec![1, 2],
-        monitor: Monitor::MovieAndCollection,
+        monitor: MovieMonitor::MovieAndCollection,
         no_search_for_movie: true,
       };
 
@@ -411,17 +421,20 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
     async fn test_handle_add_root_folder_command() {
       let expected_root_folder_path = "/nfs/test".to_owned();
+      let expected_add_root_folder_body = AddRootFolderBody {
+        path: expected_root_folder_path.clone(),
+      };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::AddRootFolder(Some(expected_root_folder_path.clone())).into(),
+          RadarrEvent::AddRootFolder(expected_add_root_folder_body).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -429,7 +442,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let add_root_folder_command = RadarrAddCommand::RootFolder {
         root_folder_path: expected_root_folder_path,
       };
@@ -439,7 +452,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -457,7 +470,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let add_tag_command = RadarrAddCommand::Tag {
         name: expected_tag_name,
       };
@@ -466,7 +479,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/radarr/delete_command_handler.rs

@@ -7,9 +7,8 @@ use tokio::sync::Mutex;
 use crate::{
   app::App,
   cli::{CliCommandHandler, Command},
-  execute_network_event,
   models::radarr_models::DeleteMovieParams,
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 
 use super::RadarrCommand;
@@ -85,19 +84,28 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrDeleteCommand> for RadarrDeleteComm
     }
   }
 
-  async fn handle(self) -> Result<()> {
+  async fn handle(self) -> Result<String> {
-    match self.command {
+    let result = match self.command {
       RadarrDeleteCommand::BlocklistItem { blocklist_item_id } => {
-        execute_network_event!(
+        let resp = self
-          self,
+          .network
-          RadarrEvent::DeleteBlocklistItem(Some(blocklist_item_id))
+          .handle_network_event(RadarrEvent::DeleteBlocklistItem(blocklist_item_id).into())
-        );
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrDeleteCommand::Download { download_id } => {
-        execute_network_event!(self, RadarrEvent::DeleteDownload(Some(download_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DeleteDownload(download_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrDeleteCommand::Indexer { indexer_id } => {
-        execute_network_event!(self, RadarrEvent::DeleteIndexer(Some(indexer_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DeleteIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrDeleteCommand::Movie {
         movie_id,
@@ -109,16 +117,28 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrDeleteCommand> for RadarrDeleteComm
           delete_movie_files: delete_files_from_disk,
           add_list_exclusion,
         };
-        execute_network_event!(self, RadarrEvent::DeleteMovie(Some(delete_movie_params)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DeleteMovie(delete_movie_params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrDeleteCommand::RootFolder { root_folder_id } => {
-        execute_network_event!(self, RadarrEvent::DeleteRootFolder(Some(root_folder_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DeleteRootFolder(root_folder_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrDeleteCommand::Tag { tag_id } => {
-        execute_network_event!(self, RadarrEvent::DeleteTag(tag_id));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DeleteTag(tag_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/delete_command_handler_tests.rs

@@ -1,13 +1,14 @@
 #[cfg(test)]
 mod tests {
   use crate::{
-    cli::{
-      radarr::{delete_command_handler::RadarrDeleteCommand, RadarrCommand},
-      Command,
-    },
     Cli,
+    cli::{
+      Command,
+      radarr::{RadarrCommand, delete_command_handler::RadarrDeleteCommand},
+    },
   };
-  use clap::{error::ErrorKind, CommandFactory, Parser};
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+  use pretty_assertions::assert_eq;
 
   #[test]
   fn test_radarr_delete_command_from() {
@@ -29,7 +30,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "blocklist-item"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -51,12 +52,13 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
@@ -64,7 +66,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "download"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -84,19 +86,20 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
     fn test_delete_indexer_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "indexer"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -116,19 +119,20 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
     fn test_delete_movie_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "movie"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -146,12 +150,13 @@ mod tests {
       let result =
         Cli::try_parse_from(["managarr", "radarr", "delete", "movie", "--movie-id", "1"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
@@ -173,12 +178,13 @@ mod tests {
         "--add-list-exclusion",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
@@ -186,7 +192,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "root-folder"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -206,19 +212,20 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
 
     #[test]
     fn test_delete_tag_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "delete", "tag"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -231,12 +238,13 @@ mod tests {
 
       let result = Cli::try_parse_from(["managarr", "radarr", "delete", "tag", "--tag-id", "1"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
+      let Some(Command::Radarr(RadarrCommand::Delete(delete_command))) = result.unwrap().command
-      {
+      else {
-        assert_eq!(delete_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(delete_command, expected_args);
     }
   }
 
@@ -250,14 +258,14 @@ mod tests {
     use crate::{
       app::App,
       cli::{
-        radarr::delete_command_handler::{RadarrDeleteCommand, RadarrDeleteCommandHandler},
         CliCommandHandler,
+        radarr::delete_command_handler::{RadarrDeleteCommand, RadarrDeleteCommandHandler},
       },
       models::{
-        radarr_models::{DeleteMovieParams, RadarrSerdeable},
         Serdeable,
+        radarr_models::{DeleteMovieParams, RadarrSerdeable},
       },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     #[tokio::test]
@@ -267,7 +275,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteBlocklistItem(Some(expected_blocklist_item_id)).into(),
+          RadarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -275,7 +283,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_blocklist_item_command = RadarrDeleteCommand::BlocklistItem {
         blocklist_item_id: 1,
       };
@@ -288,7 +296,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -298,7 +306,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteDownload(Some(expected_download_id)).into(),
+          RadarrEvent::DeleteDownload(expected_download_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -306,7 +314,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_download_command = RadarrDeleteCommand::Download { download_id: 1 };
 
       let result =
@@ -314,7 +322,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -324,7 +332,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteIndexer(Some(expected_indexer_id)).into(),
+          RadarrEvent::DeleteIndexer(expected_indexer_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -332,7 +340,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_indexer_command = RadarrDeleteCommand::Indexer { indexer_id: 1 };
 
       let result =
@@ -340,7 +348,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -354,7 +362,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteMovie(Some(expected_delete_movie_params)).into(),
+          RadarrEvent::DeleteMovie(expected_delete_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -362,7 +370,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_movie_command = RadarrDeleteCommand::Movie {
         movie_id: 1,
         delete_files_from_disk: true,
@@ -374,7 +382,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -384,7 +392,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteRootFolder(Some(expected_root_folder_id)).into(),
+          RadarrEvent::DeleteRootFolder(expected_root_folder_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -392,7 +400,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_root_folder_command = RadarrDeleteCommand::RootFolder { root_folder_id: 1 };
 
       let result =
@@ -400,7 +408,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -418,7 +426,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let delete_tag_command = RadarrDeleteCommand::Tag { tag_id: 1 };
 
       let result =
@@ -426,7 +434,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/radarr/edit_command_handler.rs

@@ -6,16 +6,15 @@ use tokio::sync::Mutex;
 
 use crate::{
   app::App,
-  cli::{mutex_flags_or_default, mutex_flags_or_option, CliCommandHandler, Command},
+  cli::{CliCommandHandler, Command, mutex_flags_or_default, mutex_flags_or_option},
-  execute_network_event,
   models::{
-    radarr_models::{
-      EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings,
-      MinimumAvailability, RadarrSerdeable,
-    },
     Serdeable,
+    radarr_models::{
+      EditCollectionParams, EditMovieParams, IndexerSettings, MinimumAvailability, RadarrSerdeable,
+    },
+    servarr_models::EditIndexerParams,
   },
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 
 use super::RadarrCommand;
@@ -339,8 +338,8 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
     }
   }
 
-  async fn handle(self) -> Result<()> {
+  async fn handle(self) -> Result<String> {
-    match self.command {
+    let result = match self.command {
       RadarrEditCommand::AllIndexerSettings {
         allow_hardcoded_subs,
         disable_allow_hardcoded_subs,
@@ -380,20 +379,16 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
             rss_sync_interval: rss_sync_interval
               .unwrap_or(previous_indexer_settings.rss_sync_interval),
             whitelisted_hardcoded_subs: whitelisted_subtitle_tags
-              .clone()
+              .unwrap_or(previous_indexer_settings.whitelisted_hardcoded_subs.text)
-              .unwrap_or_else(|| {
-                previous_indexer_settings
-                  .whitelisted_hardcoded_subs
-                  .text
-                  .clone()
-              })
               .into(),
           };
-          execute_network_event!(
+          self
-            self,
+            .network
-            RadarrEvent::EditAllIndexerSettings(Some(params)),
+            .handle_network_event(RadarrEvent::EditAllIndexerSettings(params).into())
-            "All indexer settings updated"
+            .await?;
-          );
+          "All indexer settings updated".to_owned()
+        } else {
+          String::new()
         }
       }
       RadarrEditCommand::Collection {
@@ -417,11 +412,11 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
           root_folder_path,
           search_on_add: search_on_add_value,
         };
-        execute_network_event!(
+        self
-          self,
+          .network
-          RadarrEvent::EditCollection(Some(edit_collection_params)),
+          .handle_network_event(RadarrEvent::EditCollection(edit_collection_params).into())
-          "Collection Updated"
+          .await?;
-        );
+        "Collection updated".to_owned()
       }
       RadarrEditCommand::Indexer {
         indexer_id,
@@ -454,15 +449,16 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
           api_key,
           seed_ratio,
           tags: tag,
+          tag_input_string: None,
           priority,
           clear_tags,
         };
 
-        execute_network_event!(
+        self
-          self,
+          .network
-          RadarrEvent::EditIndexer(Some(edit_indexer_params)),
+          .handle_network_event(RadarrEvent::EditIndexer(edit_indexer_params).into())
-          "Indexer updated"
+          .await?;
-        );
+        "Indexer updated".to_owned()
       }
       RadarrEditCommand::Movie {
         movie_id,
@@ -482,17 +478,18 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
           quality_profile_id,
           root_folder_path,
           tags: tag,
+          tag_input_string: None,
           clear_tags,
         };
 
-        execute_network_event!(
+        self
-          self,
+          .network
-          RadarrEvent::EditMovie(Some(edit_movie_params)),
+          .handle_network_event(RadarrEvent::EditMovie(edit_movie_params).into())
-          "Movie updated"
+          .await?;
-        );
+        "Movie Updated".to_owned()
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/edit_command_handler_tests.rs

@@ -1,13 +1,14 @@
 #[cfg(test)]
 mod tests {
   use crate::{
-    cli::{
-      radarr::{edit_command_handler::RadarrEditCommand, RadarrCommand},
-      Command,
-    },
     Cli,
+    cli::{
+      Command,
+      radarr::{RadarrCommand, edit_command_handler::RadarrEditCommand},
+    },
   };
-  use clap::{error::ErrorKind, CommandFactory, Parser};
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+  use pretty_assertions::assert_eq;
 
   #[test]
   fn test_radarr_edit_command_from() {
@@ -41,7 +42,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "edit", "all-indexer-settings"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -59,7 +60,7 @@ mod tests {
         "--disable-allow-hardcoded-subs",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -74,7 +75,7 @@ mod tests {
         "--disable-prefer-indexer-flags",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -98,7 +99,7 @@ mod tests {
         flag,
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -125,11 +126,12 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -167,11 +169,12 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -179,7 +182,7 @@ mod tests {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "edit", "collection"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -197,7 +200,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -217,7 +220,7 @@ mod tests {
         "--disable-monitoring",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -234,7 +237,7 @@ mod tests {
         "--disable-search-on-add",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -251,7 +254,7 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -269,7 +272,7 @@ mod tests {
         flag,
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -297,11 +300,12 @@ mod tests {
         "/test",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -333,18 +337,19 @@ mod tests {
         "--search-on-add",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
     fn test_edit_indexer_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "edit", "indexer"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -362,7 +367,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -382,7 +387,7 @@ mod tests {
         "--disable-rss",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -399,7 +404,7 @@ mod tests {
         "--disable-automatic-search",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -416,7 +421,7 @@ mod tests {
         "--disable-interactive-search",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -434,7 +439,7 @@ mod tests {
         "--clear-tags",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -452,7 +457,7 @@ mod tests {
         flag,
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -486,11 +491,12 @@ mod tests {
         "Test",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -525,11 +531,12 @@ mod tests {
         "2",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -577,18 +584,19 @@ mod tests {
         "25",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
     fn test_edit_movie_requires_arguments() {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", "edit", "movie"]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -606,7 +614,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -626,7 +634,7 @@ mod tests {
         "--disable-monitoring",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -644,7 +652,7 @@ mod tests {
         "--clear-tags",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
     }
 
@@ -668,7 +676,7 @@ mod tests {
         flag,
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -685,7 +693,7 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -713,11 +721,12 @@ mod tests {
         "/nfs/test",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -746,11 +755,12 @@ mod tests {
         "2",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
 
     #[test]
@@ -786,11 +796,12 @@ mod tests {
         "2",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::Edit(edit_command))) = result.unwrap().command else {
-        assert_eq!(edit_command, expected_args);
+        panic!("Unexpected command type");
-      }
+      };
+      assert_eq!(edit_command, expected_args);
     }
   }
 
@@ -804,17 +815,18 @@ mod tests {
     use crate::{
       app::App,
       cli::{
-        radarr::edit_command_handler::{RadarrEditCommand, RadarrEditCommandHandler},
         CliCommandHandler,
+        radarr::edit_command_handler::{RadarrEditCommand, RadarrEditCommandHandler},
       },
       models::{
-        radarr_models::{
-          EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings,
-          MinimumAvailability, RadarrSerdeable,
-        },
         Serdeable,
+        radarr_models::{
+          EditCollectionParams, EditMovieParams, IndexerSettings, MinimumAvailability,
+          RadarrSerdeable,
+        },
+        servarr_models::EditIndexerParams,
       },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     #[tokio::test]
@@ -855,7 +867,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditAllIndexerSettings(Some(expected_edit_all_indexer_settings)).into(),
+          RadarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -863,7 +875,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_all_indexer_settings_command = RadarrEditCommand::AllIndexerSettings {
         allow_hardcoded_subs: true,
         disable_allow_hardcoded_subs: false,
@@ -885,7 +897,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -926,7 +938,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditAllIndexerSettings(Some(expected_edit_all_indexer_settings)).into(),
+          RadarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -934,7 +946,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_all_indexer_settings_command = RadarrEditCommand::AllIndexerSettings {
         allow_hardcoded_subs: false,
         disable_allow_hardcoded_subs: true,
@@ -956,12 +968,12 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
-    async fn test_handle_edit_all_indexer_settings_command_unprovided_values_default_to_previous_values(
+    async fn test_handle_edit_all_indexer_settings_command_unprovided_values_default_to_previous_values()
-    ) {
+     {
       let expected_edit_all_indexer_settings = IndexerSettings {
         allow_hardcoded_subs: true,
         availability_delay: 2,
@@ -998,7 +1010,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditAllIndexerSettings(Some(expected_edit_all_indexer_settings)).into(),
+          RadarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1006,7 +1018,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_all_indexer_settings_command = RadarrEditCommand::AllIndexerSettings {
         allow_hardcoded_subs: false,
         disable_allow_hardcoded_subs: false,
@@ -1028,7 +1040,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1045,7 +1057,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1053,7 +1065,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_collection_command = RadarrEditCommand::Collection {
         collection_id: 1,
         enable_monitoring: true,
@@ -1070,7 +1082,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1087,7 +1099,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1095,7 +1107,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_collection_command = RadarrEditCommand::Collection {
         collection_id: 1,
         enable_monitoring: false,
@@ -1112,7 +1124,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1129,7 +1141,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1137,7 +1149,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_collection_command = RadarrEditCommand::Collection {
         collection_id: 1,
         enable_monitoring: false,
@@ -1154,7 +1166,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1169,6 +1181,7 @@ mod tests {
         api_key: Some("testKey".to_owned()),
         seed_ratio: Some("1.2".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         priority: Some(25),
         clear_tags: false,
       };
@@ -1176,7 +1189,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditIndexer(Some(expected_edit_indexer_params)).into(),
+          RadarrEvent::EditIndexer(expected_edit_indexer_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1184,7 +1197,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_indexer_command = RadarrEditCommand::Indexer {
         indexer_id: 1,
         name: Some("Test".to_owned()),
@@ -1207,7 +1220,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1222,6 +1235,7 @@ mod tests {
         api_key: Some("testKey".to_owned()),
         seed_ratio: Some("1.2".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         priority: Some(25),
         clear_tags: false,
       };
@@ -1229,7 +1243,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditIndexer(Some(expected_edit_indexer_params)).into(),
+          RadarrEvent::EditIndexer(expected_edit_indexer_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1237,7 +1251,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_indexer_command = RadarrEditCommand::Indexer {
         indexer_id: 1,
         name: Some("Test".to_owned()),
@@ -1260,7 +1274,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1275,6 +1289,7 @@ mod tests {
         api_key: Some("testKey".to_owned()),
         seed_ratio: Some("1.2".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         priority: Some(25),
         clear_tags: false,
       };
@@ -1282,7 +1297,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditIndexer(Some(expected_edit_indexer_params)).into(),
+          RadarrEvent::EditIndexer(expected_edit_indexer_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1290,7 +1305,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_indexer_command = RadarrEditCommand::Indexer {
         indexer_id: 1,
         name: Some("Test".to_owned()),
@@ -1313,7 +1328,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1325,13 +1340,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1339,7 +1355,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_movie_command = RadarrEditCommand::Movie {
         movie_id: 1,
         enable_monitoring: true,
@@ -1355,7 +1371,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1367,13 +1383,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1381,7 +1398,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_movie_command = RadarrEditCommand::Movie {
         movie_id: 1,
         enable_monitoring: false,
@@ -1397,7 +1414,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -1409,13 +1426,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1423,7 +1441,7 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
       let edit_movie_command = RadarrEditCommand::Movie {
         movie_id: 1,
         enable_monitoring: false,
@@ -1439,7 +1457,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }