docs: Updated the pull request template

docs: Added documentation on how to configure Chaptarr in Managarr
docs: Updated the contribution guidelines and PR template to sound more like AI is allowed but only when disclosed
2026-09-30 00:11:56 -06:00 · 2026-09-30 00:03:29 -06:00 · 2026-09-29 23:46:40 -06:00 · 2026-09-29 23:36:11 -06:00 · 2026-09-29 23:30:30 -06:00 · 2026-09-29 23:25:19 -06:00
1511 changed files with 189718 additions and 26314 deletions
@@ -0,0 +1,4 @@
 --artifact-server-path=./.act/artifacts
 --cache-server-path=./.act/cache
 --container-options --privileged
 --env ACT=true
@@ -7,8 +7,5 @@ echo "Running pre-push hook:"
 echo "Executing: cargo fmt"
 cargo fmt
-echo "Executing: make lint"
+echo "Executing: cargo clippy --all"
-make lint
+cargo clippy --all
 echo "Executing: cargo test"
 cargo test
@@ -7,8 +7,8 @@ echo "Running pre-push hook:"
 echo "Executing: cargo fmt --check"
 cargo fmt --check
-echo "Executing: make lint"
+echo "Executing: cargo clippy --all"
-make lint
+cargo clippy --all
-echo "Executing: cargo test"
+echo "Executing: cargo test --all"
-cargo test
+cargo test --all
@@ -0,0 +1,18 @@
 ### Description
 <!-- What problem is this PR solving? -->
 ### Alternatives Considered (Optional)
 <!-- What alternatives did you consider? Why did you choose this approach? -->
 ### AI assistance (if any)
 <!-- Required if AI assistance was used to write or modify code in this PR. -->
 <!-- - List tools here -->
 ### Authorship & Understanding
 - [ ] I wrote or heavily modified this code myself. If I didn't, I gave proper attribution to AI assistance above.
 - [ ] 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 above
@@ -21,7 +21,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
@@ -46,7 +46,7 @@ jobs:
        toolchain: [stable, beta]
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
@@ -54,7 +54,7 @@ jobs:
          components: clippy
      - name: Run clippy action
-        uses: clechasseur/rs-clippy-check@v3
+        uses: clechasseur/rs-clippy-check@v5
      - name: Cache Cargo dependencies
        uses: Swatinem/rust-cache@v2
@@ -65,7 +65,7 @@ jobs:
    name: nightly / doc
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
      - name: Install Rust nightly
        uses: dtolnay/rust-toolchain@nightly
@@ -76,15 +76,15 @@ jobs:
          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.95.0 / check
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
-      - name: Install 1.82.0
+      - name: Install 1.95.0
        uses: dtolnay/rust-toolchain@master
        with:
-          toolchain: 1.82.0
+          toolchain: 1.95.0
-      - name: cargo +1.82.0 check
+      - name: cargo +1.95.0 check
        run: cargo check
@@ -8,9 +8,9 @@ on:
  workflow_dispatch:
    inputs:
      bump_type:
-        description: "Specify the type of version bump"
+        description: 'Specify the type of version bump'
        required: true
-        default: "patch"
+        default: 'patch'
        type: choice
        options:
          - patch
@@ -23,6 +23,7 @@ jobs:
    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
@@ -30,20 +31,27 @@ jobs:
          ssh-keyscan -H github.com >> ~/.ssh/known_hosts
      - name: Checkout repository
-        uses: actions/checkout@v3
+        if: env.ACT != 'true'
        uses: actions/checkout@v5
        with:
          ssh-key: ${{ secrets.RELEASE_BOT_SSH_KEY }}
          fetch-depth: 0
-      - name: Set up Python
+      - name: Checkout repository
-        uses: actions/setup-python@v4
+        if: env.ACT == 'true'
        uses: actions/checkout@v5
        with:
-          python-version: "3.10"
+          fetch-depth: 0
      - name: Set up Python
        uses: actions/setup-python@v6
        with:
          python-version: '3.10'
      - name: Install Commitizen
        run: |
-          python -m pip install --upgrade pip
+          python3 -m pip install --upgrade pip
-          pip install commitizen
+          pip3 install commitizen==4.8.3
          npm install -g conventional-changelog-cli
      - name: Configure Git user
@@ -62,12 +70,6 @@ jobs:
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
      - name: Update the Cargo.lock
        run: |
          cargo update
          git add Cargo.lock
          git commit -m "chore: Bump the version in Cargo.lock"
      - name: Get the new version tag
        id: version
        run: |
@@ -84,25 +86,154 @@ jobs:
          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: |
-          changelog=$(conventional-changelog -p angular -i CHANGELOG.md -s --from ${{ env.prev_version }} --to ${{ env.version }})
+          conventional-changelog -p angular -i CHANGELOG.md --from ${{ env.prev_version }} --to v${{ env.version }} > artifacts/changelog.md
          echo "$changelog" > artifacts/changelog.md
          echo "changelog_body=$(cat artifacts/changelog.md)" >> $GITHUB_ENV
      - 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@v3
+        uses: actions/upload-artifact@v6
        with:
          name: artifacts
          path: artifacts
      - name: Upload the changed Cargo files (Act)
        if: env.ACT == 'true'
        uses: actions/upload-artifact@v6
        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]
@@ -130,28 +261,36 @@ jobs:
    steps:
      - name: Check if actor is repository owner
-        if: ${{ github.actor != github.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
+        uses: actions/checkout@v5
        with:
          fetch-depth: 1
      - name: Ensure repository is up-to-date
        if: env.ACT != 'true'
        run: |
          git fetch --all
          git pull
-      - uses: actions/cache@v3
+      - name: Get bumped Cargo files (Act)
        if: env.ACT == 'true'
        uses: actions/download-artifact@v7
        with:
          name: bumped-cargo-files
          path: ${{ github.workspace }}
      - uses: actions/cache@v5
        name: Cache Cargo registry
        with:
          path: ~/.cargo/registry
          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
-      - uses: actions/cache@v3
+      - uses: actions/cache@v5
        if: startsWith(matrix.job.name, 'linux-')
        with:
          path: ~/.cargo/bin
@@ -236,28 +375,36 @@ jobs:
          cp target/${{ matrix.job.target }}/release/${{ env.RELEASE_NAME }}.sha256 artifacts/
      - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v6
        with:
-          name: artifacts
+          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
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - name: Download all artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v7
        with:
          name: artifacts
          path: artifacts
          merge-multiple: true
      - name: Ensure repository is up-to-date
        if: env.ACT != 'true'
        run: |
          git fetch --all
          git pull
@@ -266,11 +413,15 @@ jobs:
        run: |
          release_version="$(cat ./artifacts/release-version)"
          echo "RELEASE_VERSION=$release_version" >> $GITHUB_ENV
-          changelog_body="$(cat ./artifacts/changelog.md)"
+
-          echo "changelog_body=$(cat artifacts/changelog.md)" >> $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
-        uses: softprops/action-gh-release@v1
+        if: env.ACT != 'true'
        uses: softprops/action-gh-release@v3
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
@@ -300,201 +451,238 @@ jobs:
            artifacts/managarr-armv7-musl.tar.gz
            artifacts/managarr-armv7-musl.sha256
          tag_name: v${{ env.RELEASE_VERSION }}
-          name: "v${{ env.RELEASE_VERSION }}"
+          name: 'v${{ env.RELEASE_VERSION }}'
-          body: ${{ env.changelog_body }}
+          body_path: artifacts/changelog.md
          draft: false
          prerelease: false
      - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v6
        with:
          name: artifacts
          path: artifacts
          overwrite: true
-  # publish-chocolatey-package:
+  publish-chocolatey-package:
-  #   needs: [publish-github-release]
+    needs: [publish-github-release]
-  #   name: Publish Chocolatey Package
+    name: Publish Chocolatey Package
-  #   runs-on: windows-latest
+    runs-on: windows-latest
-  #   steps:
+    steps:
-  #     - name: Checkout repository
+      - name: Check if actor is repository owner
-  #       uses: actions/checkout@v4
+        if: ${{ github.actor != github.repository_owner  && env.ACT != 'true' }}
-  #       with:
+        run: |
-  #         fetch-depth: 1
+          echo "You are not authorized to run this workflow."
          exit 1
-  #     - name: Get release artifacts
+      - name: Checkout repository
-  #       uses: actions/download-artifact@v3
+        uses: actions/checkout@v5
-  #       with:
+        with:
-  #         name: artifacts
+          fetch-depth: 1
  #         path: artifacts
-  #     - name: Set release assets and version
+      - name: Get release artifacts
-  #       shell: pwsh
+        uses: actions/download-artifact@v7
-  #       run: |
+        with:
-  #         # Read the first column from the SHA256 file
+          path: artifacts
-  #         $windows_sha = Get-Content ./artifacts/managarr-windows.sha256 | ForEach-Object { $_.Split(' ')[0] }
+          merge-multiple: true
  #         Add-Content -Path $env:GITHUB_ENV -Value "WINDOWS_SHA=$windows_sha"
-  #         # Read the release version from the release-version file
+      - name: Set release assets and version
-  #         $release_version = Get-Content ./artifacts/release-version
+        shell: pwsh
-  #         Add-Content -Path $env:GITHUB_ENV -Value "RELEASE_VERSION=$release_version"
+        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"
-  #     - name: Validate release environment variables
+          # Read the release version from the release-version file
-  #       run: |
+          $release_version = Get-Content ./artifacts/release-version
-  #         echo "Release SHA windows: ${{ env.WINDOWS_SHA }}"
+          Add-Content -Path $env:GITHUB_ENV -Value "RELEASE_VERSION=$release_version"
  #         echo "Release version: ${{ env.RELEASE_VERSION }}"
-  #     - name: Package and Publish package to Chocolatey
+      - name: Validate release environment variables
-  #       run: |
+        run: |
-  #         mkdir ./deployment/chocolatey/tools
+          echo "Release SHA windows: ${{ env.WINDOWS_SHA }}"
-  #         # Run packaging script
+          echo "Release version: ${{ env.RELEASE_VERSION }}"
  #         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
+      - name: Package and Publish package to Chocolatey
-  #         cd ./deployment/chocolatey
+        if: env.ACT != 'true'
-  #         choco pack
+        run: |
-  #         echo y | choco install managarr -dv -s .
+          mkdir ./deployment/chocolatey/tools
-  #         $version = managarr --version
+          # Run packaging script
-  #         $version = $version -replace " ", "."
+          python "./deployment/chocolatey/packager.py" ${{ env.RELEASE_VERSION }} "./deployment/chocolatey/managarr.nuspec.template" "./deployment/chocolatey/managarr.nuspec" ${{ env.WINDOWS_SHA }}
-  #         choco push $version.nupkg -s https://push.chocolatey.org/ --api-key ${{ secrets.CHOCOLATEY_API_KEY }};
+          python "./deployment/chocolatey/packager.py" ${{ env.RELEASE_VERSION }} "./deployment/chocolatey/chocolateyinstall.ps1.template" "./deployment/chocolatey/tools/chocolateyinstall.ps1" ${{ env.WINDOWS_SHA }}
-  # publish-homebrew-formula:
+          # Publish to Chocolatey
-  #   needs: [publish-github-release]
+          cd ./deployment/chocolatey
-  #   name: Update Homebrew formulas
+          choco pack
-  #   runs-on: ubuntu-latest
+          echo y | choco install managarr -dv -s .
-  #   steps:
+          $version = managarr --version
-  #     - name: Checkout repository
+          $version = $version -replace " ", "."
-  #       uses: actions/checkout@v4
+          choco push $version.nupkg -s https://push.chocolatey.org/ --api-key ${{ secrets.CHOCOLATEY_API_KEY }};
  #       with:
  #         fetch-depth: 1
-  #     - name: Get release artifacts
+  publish-homebrew-formula:
-  #       uses: actions/download-artifact@v3
+    needs: [publish-github-release]
-  #       with:
+    name: Update Homebrew formulas
-  #         name: artifacts
+    runs-on: ubuntu-latest
-  #         path: artifacts
+    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: Set release assets and version
+      - name: Checkout repository
-  #       shell: bash
+        uses: actions/checkout@v5
-  #       run: |
+        with:
-  #         # Set environment variables
+          fetch-depth: 1
  #         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
+      - name: Get release artifacts
-  #       run: |
+        uses: actions/download-artifact@v7
-  #         echo "Release SHA macos: ${{ env.MACOS_SHA }}"
+        with:
-  #         echo "Release SHA macos-arm: ${{ env.MACOS_SHA_ARM }}"
+          path: artifacts
-  #         echo "Release SHA linux musl: ${{ env.LINUX_SHA }}"
+          merge-multiple: true
  #         echo "Release version: ${{ env.RELEASE_VERSION }}"
-  #     - name: Execute Homebrew packaging script
+      - name: Set release assets and version
-  #       run: |
+        shell: bash
-  #         # run packaging script
+        run: |
-  #         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 }}
+          # 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: Push changes to Homebrew tap
+      - name: Validate release environment variables
-  #       env:
+        run: |
-  #         TOKEN: ${{ secrets.MANAGARR_GITHUB_TOKEN }}
+          echo "Release SHA macos: ${{ env.MACOS_SHA }}"
-  #       run: |
+          echo "Release SHA macos-arm: ${{ env.MACOS_SHA_ARM }}"
-  #         # push to Git
+          echo "Release SHA linux musl: ${{ env.LINUX_SHA }}"
-  #         git config --global user.name "Dark-Alex-17"
+          echo "Release version: ${{ env.RELEASE_VERSION }}"
  #         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:
+      - name: Execute Homebrew packaging script
-  #   needs: [publish-github-release]
+        if: env.ACT != 'true'
-  #   name: Publishing Docker image to Docker Hub
+        run: |
-  #   runs-on: ubuntu-latest
+          # run packaging script
-  #   steps:
+          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: Checkout repository
  #       uses: actions/checkout@v4
  #       with:
  #         fetch-depth: 1
-  #     - name: Get release artifacts
+      - name: Push changes to Homebrew tap
-  #       uses: actions/download-artifact@v3
+        if: env.ACT != 'true'
-  #       with:
+        env:
-  #         name: artifacts
+          TOKEN: ${{ secrets.MANAGARR_GITHUB_TOKEN }}
-  #         path: artifacts
+        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
-  #     - name: Set version variable
+  publish-docker-image:
-  #       run: |
+    needs: [publish-github-release]
-  #         version="$(cat artifacts/release-version)"
+    name: Publishing Docker image to Docker Hub
-  #         echo "version=$version" >> $GITHUB_ENV
+    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: Validate release environment variables
+      - name: Checkout repository
-  #       run: |
+        uses: actions/checkout@v5
-  #         echo "Release version: ${{ env.version }}"
+        with:
          fetch-depth: 1
-  #     - name: Set up QEMU
+      - name: Get release artifacts
-  #       uses: docker/setup-qemu-action@v3
+        uses: actions/download-artifact@v7
        with:
          path: artifacts
          merge-multiple: true
-  #     - name: Set up Docker Buildx
+      - name: Ensure repository is up-to-date
-  #       uses: docker/setup-buildx-action@v3
+        if: env.ACT != 'true'
        run: |
          git fetch --all
          git pull
-  #     - name: Login to Docker Hub
+      - name: Set version variable
-  #       uses: docker/login-action@v3
+        run: |
-  #       with:
+          version="$(cat artifacts/release-version)"
-  #         username: ${{ secrets.DOCKER_USERNAME }}
+          echo "version=$version" >> $GITHUB_ENV
  #         password: ${{ secrets.DOCKER_PASSWORD }}
-  #     - name: Push to Docker Hub
+      - name: Validate release environment variables
-  #       uses: docker/build-push-action@v5
+        run: |
-  #       with:
+          echo "Release version: ${{ env.version }}"
  #         context: .
  #         file: Dockerfile
  #         platforms: linux/amd64,linux/arm64
  #         push: true
  #         tags: darkalex17/managarr:latest, darkalex17/managarr:${{ env.version }}
-  # publish-crate:
+      - name: Set up QEMU
-  #   needs: publish-github-release
+        uses: docker/setup-qemu-action@v4
  #   name: Publish Crate
  #   runs-on: ubuntu-latest
  #   steps:
  #     - name: Check if actor is repository owner
  #       if: ${{ github.actor != github.repository_owner }}
  #       run: |
  #         echo "You are not authorized to run this workflow."
  #         exit 1
-  #     - name: Checkout
+      - name: Set up Docker Buildx
-  #       uses: actions/checkout@v4
+        uses: docker/setup-buildx-action@v4
  #       with:
  #         fetch-depth: 0
-  #     - name: Ensure repository is up-to-date
+      - name: Login to Docker Hub
-  #       run: |
+        if: env.ACT != 'true'
-  #         git fetch --all
+        uses: docker/login-action@v4
-  #         git pull
+        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
-  #     - uses: actions/cache@v3
+      - name: Push to Docker Hub
-  #       name: Cache Cargo registry
+        uses: docker/build-push-action@v7
-  #       with:
+        with:
-  #         path: ~/.cargo/registry
+          context: .
-  #         key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
+          file: Dockerfile
          platforms: linux/amd64,linux/arm64
          push: ${{ env.ACT != 'true' }}
          tags: darkalex17/managarr:latest, darkalex17/managarr:${{ env.version }}
-  #     - uses: actions/cache@v3
+  publish-crate:
-  #       with:
+    needs: publish-github-release
-  #         path: ~/.cargo/bin
+    name: Publish Crate
-  #         key: ${{ runner.os }}-cargo-bin-${{ hashFiles('.github/workflows/release.yml') }}
+    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: Install Rust stable
+      - name: Checkout
-  #       uses: dtolnay/rust-toolchain@stable
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0
-  #     - uses: katyo/publish-crates@v2
+      - name: Get bumped Cargo files (Act)
-  #       with:
+        if: env.ACT == 'true'
-  #         registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        uses: actions/download-artifact@v7
        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@v5
        name: Cache Cargo registry
        with:
          path: ~/.cargo/registry
          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
      - uses: actions/cache@v5
        with:
          path: ~/.cargo/bin
          key: ${{ runner.os }}-cargo-bin-${{ hashFiles('.github/workflows/release.yml') }}
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
      - uses: katyo/publish-crates@v2
        if: env.ACT != 'true'
        with:
          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
@@ -33,7 +33,7 @@ jobs:
        # toolchain
        toolchain: [stable, beta]
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
      - name: Install ${{ matrix.toolchain }}
        uses: dtolnay/rust-toolchain@master
@@ -48,51 +48,51 @@ jobs:
      - name: cargo test --locked
        run: cargo test --locked --all-features --all-targets
-  minimal-versions:
+  # minimal-versions:
-    # This action chooses the oldest version of the dependencies permitted by Cargo.toml to ensure
+  #   # This action chooses the oldest version of the dependencies permitted by Cargo.toml to ensure
-    # that this crate is compatible with the minimal version that this crate and its dependencies
+  #   # that this crate is compatible with the minimal version that this crate and its dependencies
-    # require. This will pickup issues where this create relies on functionality that was introduced
+  #   # require. This will pickup issues where this create relies on functionality that was introduced
-    # later than the actual version specified (e.g., when we choose just a major version, but a
+  #   # later than the actual version specified (e.g., when we choose just a major version, but a
-    # method was added after this version).
+  #   # method was added after this version).
-    #
+  #   #
-    # This particular check can be difficult to get to succeed as often transitive dependencies may
+  #   # 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
+  #   # be incorrectly specified (e.g., a dependency specifies 1.0 but really requires 1.1.5). There
-    # is an alternative flag available -Zdirect-minimal-versions that uses the minimal versions for
+  #   # is an alternative flag available -Zdirect-minimal-versions that uses the minimal versions for
-    # direct dependencies of this crate, while selecting the maximal versions for the transitive
+  #   # direct dependencies of this crate, while selecting the maximal versions for the transitive
-    # dependencies. Alternatively, you can add a line in your Cargo.toml to artificially increase
+  #   # dependencies. Alternatively, you can add a line in your Cargo.toml to artificially increase
-    # the minimal dependency, which you do with e.g.:
+  #   # the minimal dependency, which you do with e.g.:
-    # ```toml
+  #   # ```toml
-    # # for minimal-versions
+  #   # # for minimal-versions
-    # [target.'cfg(any())'.dependencies]
+  #   # [target.'cfg(any())'.dependencies]
-    # openssl = { version = "0.10.55", optional = true } # needed to allow foo to build with -Zminimal-versions
+  #   # 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
+  #   # 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
+  #   # by your library, and the target bit is so that this dependency edge never actually affects
-    # Cargo build order. See also
+  #   # Cargo build order. See also
-    # https://github.com/jonhoo/fantoccini/blob/fde336472b712bc7ebf5b4e772023a7ba71b2262/Cargo.toml#L47-L49.
+  #   # https://github.com/jonhoo/fantoccini/blob/fde336472b712bc7ebf5b4e772023a7ba71b2262/Cargo.toml#L47-L49.
-    # This action is run on ubuntu with the stable toolchain, as it is not expected to fail
+  #   # This action is run on ubuntu with the stable toolchain, as it is not expected to fail
-    runs-on: ubuntu-latest
+  #   runs-on: ubuntu-latest
-    name: ubuntu / stable / minimal-versions
+  #   name: ubuntu / stable / minimal-versions
-    steps:
+  #   steps:
-      - uses: actions/checkout@v4
+  #     - uses: actions/checkout@v5
-      - name: Install Rust stable
+  #     - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
+  #       uses: dtolnay/rust-toolchain@stable
-      - name: Install nightly for -Zdirect-minimal-versions
+  #     - name: Install nightly for -Zdirect-minimal-versions
-        uses: dtolnay/rust-toolchain@nightly
+  #       uses: dtolnay/rust-toolchain@nightly
-      - name: rustup default stable
+  #     - name: rustup default stable
-        run: rustup default stable
+  #       run: rustup default stable
-      - name: cargo update -Zdirect-minimal-versions
+  #     - name: cargo update -Zdirect-minimal-versions
-        run: cargo +nightly update -Zdirect-minimal-versions
+  #       run: cargo +nightly update -Zdirect-minimal-versions
-      - name: cargo test
+  #     - name: cargo test
-        run: cargo test --locked --all-features --all-targets
+  #       run: cargo test --locked --all-features --all-targets
-      - name: Cache Cargo dependencies
+  #     - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
+  #       uses: Swatinem/rust-cache@v2
  os-check:
    # run cargo test on mac and windows
@@ -110,7 +110,7 @@ jobs:
      # - run: vcpkg install openssl:x64-windows-static-md
      #   if: runner.os == 'Windows'
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
@@ -151,7 +151,7 @@ jobs:
    name: ubuntu / stable / coverage
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
@@ -175,7 +175,8 @@ jobs:
        uses: Swatinem/rust-cache@v2
      - name: Upload to codecov.io
-        uses: codecov/codecov-action@v4
+        if: env.ACT != 'true'
        uses: codecov/codecov-action@v7
        with:
          fail_ci_if_error: true
          token: ${{ secrets.CODECOV_TOKEN }}
@@ -1,3 +1,6 @@
 /target
 /.idea/
 /.scannerwork/
 /.act/
 /.sisyphus/
 /.coyote/
@@ -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"
@@ -5,6 +5,230 @@ 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).
 ## v0.7.3 (2026-06-25)
 ### Feat
 - Implemented log rolling so the log file doesn't just grow exponentially [#60]
 ### Fix
 - addressed code review comments
 - tail-logs subcommand follows log rollovers and sleeps to minimize idle CPU loops
 ### Refactor
 - Refactored several usages of sort_by_key and match guards to utilize newer Rust version APIs
 ## v0.7.2 (2026-04-20)
 ### 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
 ## 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
@@ -1,6 +1,23 @@
 # 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.
@@ -48,10 +65,38 @@ cz commit
 1. Clone this repo
 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, or AI-generated where explicitly disclosed. AI-generated code (e.g., Copilot, ChatGPT,
 Claude, etc.) is permitted only when explicitly disclosed and approved. For example: disclosing the use of AI-generated code in a PR description. 
 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!
@@ -1,6 +1,6 @@
 [package]
 name = "managarr"
-version = "0.4.2"
+version = "0.7.3"
 authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
 description = "A TUI and CLI to manage your Servarrs"
 keywords = ["managarr", "ratatui", "dashboard", "servarr", "tui"]
@@ -8,62 +8,79 @@ 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.95.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.74"
+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.28.1"
 derivative = "2.2.0"
-human-panic = "2.0.2"
+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 = ["rolling_file_appender", "compound_policy", "size_trigger", "fixed_window_roller"] }
-regex = "1.11.1"
+regex = "1.12.2"
-reqwest = { version = "0.12.9", features = ["json"] }
+reqwest = { version = "0.13.2", 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.29.0", features = [
+ratatui = { version = "0.30.0", features = [
  "all-widgets",
  "unstable-widget-ref",
 ] }
-urlencoding = "2.1.2"
+urlencoding = "2.1.3"
-clap = { version = "4.5.20", features = ["derive", "cargo", "env"] }
+clap = { version = "4.5.56", features = [
-clap_complete = "4.5.33"
+  "derive",
-itertools = "0.13.0"
+  "cargo",
-ctrlc = "3.4.5"
+  "env",
-colored = "2.1.0"
+  "wrap_help",
-async-trait = "0.1.83"
+] }
 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.24.0"
+managarr-tree-widget = "0.25.0"
-indicatif = "0.17.9"
+indicatif = "0.17.11"
-derive_setters = "0.1.6"
+derive_setters = "0.1.9"
-deunicode = "1.6.0"
+deunicode = "1.6.2"
-paste = "1.0.15"
+openssl = { version = "0.10.79", features = ["vendored"] }
-openssl = { version = "0.10.68", 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.23.0"
+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"]
@@ -74,4 +91,6 @@ name = "managarr"
 [profile.release]
 lto = true
-codegen-units = 1
+codegen-units = 3
 opt-level = "s"
 strip = true
@@ -1,4 +1,4 @@
-FROM rust:1.82 AS builder
+FROM rust:1.95 AS builder
 WORKDIR /usr/src
 # Download and compile Rust dependencies in an empty project and cache as a separate Docker layer
@@ -6,6 +6,7 @@ RUN USER=root cargo new --bin managarr-temp
 WORKDIR /usr/src/managarr-temp
 COPY Cargo.* .
 COPY proc_macros ./proc_macros
 RUN cargo build --release
 # remove src from empty project
 RUN rm -r src
@@ -20,6 +21,8 @@ RUN mv target/release/managarr .
 FROM debian:stable-slim
 RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/*
 # Copy the compiled binary from the builder container
 COPY --from=builder --chown=nonroot:nonroot /usr/src/managarr-temp/managarr /usr/local/bin
@@ -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,
@@ -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}
@@ -1,32 +1,37 @@
 # 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)
 ![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)
 ![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/sonarr/sonarr_library.png)
+![library](screenshots/lidarr/lidarr_library.png)
 ## What Servarrs are supported?
 - [x] ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
 - [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)
+- [x] ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
 - [ ] ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
 - [ ] ![whisparr_logo](logos/whisparr.png) [Whisparr](https://wiki.servarr.com/whisparr)
 - [ ] ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
 - [ ] ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)
-## Try Before You Buy
+> [!NOTE]
 > The official Readarr repository has been archived, but Managarr's Readarr support is compatible with any Readarr forks
 > that maintain compatibility with the official Readarr v1 API. See [Tested Readarr Forks](#tested-readarr-forks) below
 > for forks that have been explicitly tested with Managarr, and any oddities in configuring them to work with Managarr.
 ## 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:
@@ -54,14 +59,14 @@ Run Managarr as a docker container by mounting your `config.yml` file to `/root/
 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 popular your configuration file first before starting the container. Otherwise, the container will fail to start.
+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 and then you'll be able to install Managarr:
+To install Managarr from Homebrew, install the Managarr tap. Then you'll be able to install Managarr:
 ```shell
 brew tap Dark-Alex-17/managarr
@@ -76,6 +81,16 @@ To upgrade to a newer version of Managarr:
 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.
@@ -84,7 +99,7 @@ of Chocolatey packages take quite some time, and thus the package may not be ava
 choco install managarr
 # Some newer releases may require a version number, so you can specify it like so:
-choco install managarr --version=0.4.1
+choco install managarr --version=0.7.0
 ```
 To upgrade to the latest and greatest version of Managarr:
@@ -92,7 +107,7 @@ To upgrade to the latest and greatest version of Managarr:
 choco upgrade managarr
 # To upgrade to a specific version:
-choco upgrade managarr --version=0.4.2
+choco upgrade managarr --version=0.7.0
 ```
 ### Manual
@@ -107,16 +122,16 @@ Binaries are available on the [releases](https://github.com/Dark-Alex-17/managar
 #### Windows Instructions
 To use a binary from the releases page on Windows, do the following:
-1. Download the latest binary [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+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 [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+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` (NB: This may require `sudo`)
+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
@@ -170,13 +185,45 @@ Key:
 | ✅  | ✅  | View and browse logs, tasks, events queues, and updates                                                            |
 | ✅  | ✅  | Manually trigger scheduled tasks                                                                                   |
 ### Readarr
 - [ ] Support for Readarr
 ### Lidarr
- [ ] Support for 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
 | TUI | CLI | Feature                                                                                                        |
 |-----|-----|----------------------------------------------------------------------------------------------------------------|
 | ✅  | ✅  | View your library, downloads, blocklist, editions                                                              |
 | ✅  | ✅  | View details of a specific author, book, or edition 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 authors to your library                                                                                    |
 | ✅  | ✅  | Delete authors, books, downloads, indexers, root folders, and book files                                       |
 | ✅  | ✅  | Trigger automatic searches for authors or books                                                                |
 | ✅  | ✅  | Trigger refresh and disk scan for authors and downloads                                                        |
 | ✅  | ✅  | Manually search for author releases or books                                                                   |
 | ✅  | ✅  | Edit your authors 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                                                                               |
 ### Whisparr
@@ -194,6 +241,19 @@ Key:
 - [ ] 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. 
@@ -206,7 +266,7 @@ To see all available commands, simply run `managarr --help`:
 ```shell
 $ managarr --help
-managarr 0.4.0
+managarr 0.8.0
 Alex Clarke <alex.j.tusa@gmail.com>
 A TUI and CLI to manage your Servarrs
@@ -216,15 +276,36 @@ 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
  readarr      Commands for managing your Readarr 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:
      --disable-spinner  Disable the spinner (can sometimes make parsing output challenging) [env: MANAGARR_DISABLE_SPINNER=]
      --config <CONFIG>  The Managarr configuration file to use [env: MANAGARR_CONFIG_FILE=]
  -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 Sonarr, you would run:
@@ -253,12 +334,21 @@ Commands:
  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:
      --disable-spinner  Disable the spinner (can sometimes make parsing output challenging) [env: MANAGARR_DISABLE_SPINNER=]
      --config <CONFIG>  The Managarr configuration file to use [env: MANAGARR_CONFIG_FILE=]
  -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:
@@ -270,23 +360,49 @@ $ managarr radarr list movies | jq '.[] | select(.title == "Ad Astra") | .id'
 # Configuration
 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.
+but all servers will require you to input the API token. This means that for each Servarr you configure,
 if you define only the `api_token`, Managarr will assume the Servarr is running on `localhost` and on the
 default port for that respective service. That is:
-The configuration file is located somewhere different for each OS.
+| Servarr | Default Host | Default Port |
 |---------|--------------|--------------|
 | Radarr  | `localhost`  | 7878         |
 | Sonarr  | `localhost`  | 8989         |
 | Lidarr  | `localhost`  | 8686         |
 | Readarr | `localhost`  | 8787         |
-### Linux
+> [!TIP]
-```
+> In general, all Servarrs store their API tokens under Settings -> General -> Security -> API Key in their web UIs.
-$HOME/.config/managarr/config.yml
+
 ## Minimum Configuration Requirements
 The following configuration file will connect to each Servarr running on localhost with their default ports. The only
 requirement for each is the specification of an API token.
 ```yaml
 radarr:
  # Connect to Radarr running on localhost:7878
  - api_token: <your-radarr-api-token-here>
 sonarr:
  # Connect to sonarr running on localhost:8989
  - api_token: <your-sonarr-api-token-here>
 lidarr:
  # Connect to lidarr running on localhost:8686
  - api_token: <your-lidarr-api-token-here>
 readarr:
  # Connect to readarr running on localhost:8787
  - api_token: <your-readarr-api-token-here>
 ```
-### Mac
+## Configuration File Location
 ```
 $HOME/Library/Application Support/managarr/config.yml
 ```
-### Windows
+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:
-%APPDATA%/Roaming/managarr/config.yml
+
 ```shell
 managarr config-path
 ```
 ## Specify Which Configuration File to Use
@@ -295,44 +411,163 @@ where you may have more than one instance of a given Servarr running. Thus, you
 config file using the `--config` flag:
 ```shell
-managarr --config /path/to/config.yml
+managarr --config-file /path/to/config.yml
 ```
 ### Example Configuration:
 ```yaml
 theme: default
 radarr:
-  host: 192.168.0.78
+  - host: 192.168.0.78
    port: 7878
    api_token: someApiToken1234567890
-  ssl_cert_path: /path/to/radarr.crt # Required to enable SSL
+    ssl_cert_path: /path/to/radarr.crt # Use the specified SSL certificate to connect to this Servarr
                                       # Enables SSL regardless of the value of the 'ssl'
                                       # See the SSL Configuration section below for more information
  - host: 192.168.0.79
    port: 7878
    api_token: someApiToken1234567890
    ssl: true # Use SSL to connect to this Servarr
              # This will assume that you have the SSL certificate installed to your system trust store
              # See the SSL Configuration section below for more information
  - uri: http://htpc.local/radarr # Example of using the 'uri' key instead of 'host' and 'port'
    api_token: someApiToken1234567890
 sonarr:
-  uri: http://htpc.local/sonarr # Example of using the 'uri' key instead of 'host' and 'port'
+  - host: 192.168.0.89
-  api_token: someApiToken1234567890
+    port: 8989
-readarr:
+    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
-  host: 192.168.0.87
+
-  port: 8787
+  - name: Anime Sonarr # An example of a custom name for a secondary Sonarr instance
    host: 192.168.1.89
    port: 8989
    api_token: someApiToken1234567890
 lidarr:
-  host: 192.168.0.86
+  - host: 192.168.0.86
    port: 8686
    api_token: ${MY_LIDARR_API_TOKEN} # Example of configuring using environment variables
    monitored_storage_paths: # Filter which Root Folders or Disk Storage you want displayed in the UI's 'Stats' block
      # Note: Setting these values does not affect what shows up in the 'Root Folders' tab of the UI.
      - /nfs    # An example disk (i.e. '<servarr> list disk-space' command) you want displayed in the UI under 'Storage:'
      - /media  # An example root folder you want displayed in the UI
                # Root folders collapse up to the super-directory to reduce duplication in the UI. For example:
                # if you have root folders '/media/tv', '/media/cartoons' and '/media/reality', and you set this
                # monitored path, the UI will show '/media/[tv,cartoons,reality]' under Root Folders
  - host: 192.168.1.86
    port: 8686
    api_token: someApiToken1234567890
-whisparr:
+    ssl_cert_path: /path/to/lidarr_1.crt
-  host: 192.168.0.69
+    custom_headers: # Example of adding custom headers to all requests to the Servarr instance
-  port: 6969
+      traefik-auth-bypass-key: someBypassKey1234567890
      SOME-OTHER-CUSTOM-HEADER: ${MY_CUSTOM_HEADER_VALUE}
 readarr:
  - name: Chaptarr (Ebooks) # Example of how to use the Readarr support with a Readarr fork like Chaptarr
    uri: http://192.168.0.87:8789/readarr/gr/ebook
    api_token: someApiToken1234567890
-  ssl_cert_path: /path/to/whisparr.crt
+```
-bazarr:
+
-  host: 192.168.0.67
+### SSL Configuration
-  port: 6767
+If your Servarr is using SSL or self-signed certificates, you may need to specify additional configuration options to connect without issues.
 **If your Servarr's domain CA is installed in the system's trust store:**
 Then you can simply specify `ssl: true` and Managarr will be able to connect to your Servarr:
 ```yaml
 radarr:
  - host: 192.168.0.78
    port: 7878
    api_token: yourApiTokenHere
    ssl: true
 ```
 **If your Servarr's domain CA is not installed:**
 You'll either need to specify the path to the certificate via the `ssl_cert_path` property, or you'll need to install the certificate into your system store.
 To acquire the cert for your Servarr's domain, you can use the following command:
 ```shell
 openssl s_client -show-certs -connect <your-servarr-domain.com>:<port> </dev/null |\
  sed -n -e '/-.BEGIN/,/-.END/ p' > /path/to/your/servarr.pem
 ```
 Now, you can either specify `ssl_cert_path: /path/to/your/servarr.pem`:
 Example configuration with a certificate that's not installed to the system trust store:
 ```yaml
 radarr:
  - host: 192.168.0.78
    port: 7878
    api_token: yourApiTokenHere
    ssl_cert_path: /path/to/your/certificate.crt
 ```
 Or install the certificate into your system's trust store.
 For example, if you're on a Debian-based system and have `ca-certificates` installed (`sudo apt install ca-certificates`):
 ```shell
 sudo mv /path/to/your/servarr.pem /usr/local/share/ca-certificates/servarr.pem
 sudo update-ca-certificates
 ```
 Example configuration with a certificate that is installed to the system trust store:
 ```yaml
 radarr:
  - host: 192.168.0.78
    port: 7878
    api_token: yourApiTokenHere
    ssl: true
 ```
 ### Example Multi-Instance Configuration:
 ```yaml
 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
-prowlarr:
+    ssl_cert_path: /path/to/radarr.crt
-  host: 192.168.0.96
+    
-  port: 9696
+  - name: International Movies
    host: 192.168.0.79
    port: 7878
    api_token: someApiToken1234567890
-tautulli:
+sonarr:
-  host: 192.168.0.81
+  - name: Anime
-  port: 8181
+    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
@@ -343,8 +578,45 @@ Managarr supports using environment variables on startup so you don't have to al
 | `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`              |
-## Track What I'm Currently Working On
+## Tested Readarr Forks
-To see what feature(s) I'm currently working on, check out my [Wekan Board](https://wekan.alexjclarke.com/b/dHoGjBb44MHM9HSv4/managarr).
+
 The following Readarr forks have been explicitly tested with Managarr:
 * [Bookshelf](https://github.com/pennydreadful/bookshelf)
 * [Readarr-Resurrected](https://github.com/ricetim/readarr-rresurrected)
 * [Librarr](https://github.com/Rorqualx/Librarr)
 * [Chaptarr](https://github.com/Chaptarr/Chaptarr)
 > [!IMPORTANT]
 > Chaptarr houses a dedicated Readarr facade middleware that activates on a path prefix, meaning a bare config doesn't 
 > work. Instead, users need to configure both Audiobooks and Ebooks separately, and based on their desired metadata 
 > fetcher (i.e. Goodreads and Hardcover IDs). Because of this, Chaptarr-based configurations must use the `uri` key 
 > rather than the `host` and `port` keys. The below configuration file demonstrates all the supported variations for
 > connecting Managarr to Chaptarr.
 ### Chaptarr Example Configuration
 ```yaml
 readarr:
  # Because Chaptarr supports both eBooks and audiobooks, the same instance must be provisioned twice if you're using 
  # both so Managarr can differentiate between the two. Thus, for Chaptarr, you need an eBook server configured and an 
  # audiobook server configured like below.
  - name: eBooks (Goodreads) # Readarr originally used Goodreads as its metadata provider
    uri: http://192.168.0.87:8789/readarr/gr/ebook # Note the `gr` in the path prefix indicating "GoodReads"
    api_token: someApiToken1234567890
  - name: Chaptarr Audiobooks (Goodreads)
    uri: http://192.168.0.105:8789/readarr/gr/audiobook
    api_token: someApiToken1234567890
  - name: Chaptarr eBooks (Hardcover)
    uri: http://192.168.0.105:8789/readarr/hc/ebook # Note the `hc` in the path prefix indicating "HardCover"
    api_token: someApiToken1234567890
  - name: Chaptarr Audiobooks (Hardcover)
    uri: http://192.168.0.105:8789/readarr/hc/audiobook
    api_token: someApiToken1234567890
 ```
 ## Screenshots
@@ -361,6 +633,20 @@ To see what feature(s) I'm currently working on, check out my [Wekan Board](http
 ![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)
 ### Readarr
 ![readarr_library](screenshots/readarr/readarr_library.png)
 ![author_details](screenshots/readarr/author_details.png)
 ![book_details](screenshots/readarr/book_details.png)
 ![manual_author_search](screenshots/readarr/manual_author_search.png)
 ![manual_album_search](screenshots/readarr/manual_book_search.png)
 ### General
 ![logs](screenshots/radarr/logs.png)
 ![indexers](screenshots/radarr/indexers.png)
@@ -376,8 +662,8 @@ To see what feature(s) I'm currently working on, check out my [Wekan Board](http
 ## Servarr Requirements
 * [Radarr >= 5.3.6.8612](https://radarr.video/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)
@@ -1,6 +1,14 @@
 coverage:
  range: "80..100"
  status:
    project:
      default:
        threshold: 0
        target: 80%
    patch:
      default:
        threshold: 0
        target: 80%
 ignore:
  - "**/*_tests.rs"
  - "src/ui"
@@ -35,7 +35,7 @@ This is a nuspec. It mostly adheres to https://docs.nuget.org/create/Nuspec-Refe
    <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. Build with love in Rust!
+    A TUI and CLI for managing *arr servers. Built with love in Rust!
    **Usage**
    To use, run `managarr` in a terminal.
@@ -1,7 +1,7 @@
 # Documentation: https://docs.brew.sh/Formula-Cookbook
 #                https://rubydoc.brew.sh/Formula
 class Managarr < Formula
-  desc "A fast and simple dashboard for Kubernetes written in Rust"
+  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"
@@ -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 -- property_tests 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 version=VERSION:
    @DOCKER_BUILDKIT=1 docker build --rm -t {{IMG_NAME}}:{{version}} .
@@ -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"
@@ -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()
 }
@@ -0,0 +1,7 @@
 use darling::FromVariant;
 #[derive(Debug, FromVariant)]
 #[darling(attributes(display_style))]
 pub struct DisplayStyleArgs {
  pub name: Option<String>,
 }
@@ -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"
@@ -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()
 }
@@ -0,0 +1,8 @@
 # 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
 cc 29df5ff471eb388b0ffde573a959a539e4cf32acd9e1cea5187bba2268dd57f7 # shrinks to list_size = 1, filter_term = "𑛀"
@@ -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"
@@ -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
@@ -1,5 +1,5 @@
 tab_spaces=2
-edition = "2021"
+edition = "2024"
 reorder_imports = true
 imports_granularity = "Crate"
 group_imports = "StdExternalCrate"
@@ -1,51 +1,91 @@
 #[cfg(test)]
 mod tests {
  use crate::models::Route;
  use anyhow::anyhow;
-  use pretty_assertions::assert_eq;
+  use pretty_assertions::{assert_eq, assert_str_eq};
-  use rstest::rstest;
+  use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
  use serde_json::Value;
  use serial_test::serial;
  use std::time::{Duration, Instant};
  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, AppConfig, Data, ServarrConfig};
+  use crate::models::servarr_data::lidarr::lidarr_data::LidarrData;
  use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
  use crate::models::servarr_data::readarr::readarr_data::{ActiveReadarrBlock, ReadarrData};
  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
  use crate::models::{HorizontallyScrollableText, TabRoute};
  use crate::network::radarr_network::RadarrEvent;
  use crate::network::NetworkEvent;
  use crate::network::radarr_network::RadarrEvent;
  use crate::network::sonarr_network::SonarrEvent;
  use tokio_util::sync::CancellationToken;
-  #[rstest]
+  #[test]
-  fn test_app_new(
+  fn test_app_new() {
-    #[values(ActiveRadarrBlock::default(), ActiveSonarrBlock::default())] servarr: impl Into<Route>
+    let radarr_config_1 = ServarrConfig {
-      + Copy,
+      name: Some("Radarr Test".to_owned()),
-  ) {
+      ..ServarrConfig::default()
    let (title, config) = match servarr.into() {
      Route::Radarr(_, _) => (
        "Radarr",
        AppConfig {
          radarr: Some(ServarrConfig::default()),
          ..AppConfig::default()
        },
      ),
      Route::Sonarr(_, _) => (
        "Sonarr",
        AppConfig {
          sonarr: Some(ServarrConfig::default()),
          ..AppConfig::default()
        },
      ),
      _ => unreachable!(),
    };
-    let tab_route = |title: &'static str| TabRoute {
+    let radarr_config_2 = ServarrConfig {
-      title,
+      weight: Some(3),
-      route: servarr.into(),
+      ..ServarrConfig::default()
-      help: format!(
+    };
-        "<↑↓> scroll | ←→ change tab | {}  ",
+    let sonarr_config_1 = ServarrConfig {
-        build_context_clue_string(&SERVARR_CONTEXT_CLUES)
+      name: Some("Sonarr Test".to_owned()),
-      ),
+      weight: Some(1),
      ..ServarrConfig::default()
    };
    let sonarr_config_2 = ServarrConfig::default();
    let readarr_config_1 = ServarrConfig {
      name: Some("Readarr Test".to_owned()),
      weight: Some(2),
      ..ServarrConfig::default()
    };
    let readarr_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,
      readarr: Some(vec![readarr_config_1.clone(), readarr_config_2.clone()]),
    };
    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: "Readarr Test".to_owned(),
        route: ActiveReadarrBlock::default().into(),
        contextual_help: None,
        config: Some(readarr_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),
      },
      TabRoute {
        title: "Readarr 1".to_owned(),
        route: ActiveReadarrBlock::default().into(),
        contextual_help: None,
        config: Some(readarr_config_2),
      },
    ];
    let app = App::new(
      mpsc::channel::<NetworkEvent>(500).0,
@@ -53,21 +93,22 @@ mod tests {
      CancellationToken::new(),
    );
-    assert!(app.navigation_stack.is_empty());
+    assert_is_empty!(app.navigation_stack);
-    assert_eq!(app.get_current_route(), servarr.into());
+    assert_eq!(app.get_current_route(), ActiveSonarrBlock::default().into());
-    assert!(app.network_tx.is_some());
+    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, vec![tab_route(title)]);
+    assert_eq!(app.server_tabs.tabs, expected_tab_routes);
    assert_eq!(app.tick_until_poll, 400);
-    assert_eq!(app.ticks_until_scroll, 4);
+    assert_eq!(app.scroll_interval, Duration::from_millis(100));
    assert_eq!(app.tick_count, 0);
    assert!(!app.should_text_scroll);
    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);
  }
@@ -75,48 +116,25 @@ mod tests {
  fn test_app_default() {
    let app = App::default();
-    assert!(app.navigation_stack.is_empty());
+    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: ActiveSonarrBlock::Series.into(),
          help: format!(
            "<↑↓> scroll | ←→ change tab | {}  ",
            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.scroll_interval, Duration::from_millis(100));
    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);
@@ -148,12 +166,42 @@ mod tests {
    assert!(app.is_routing);
  }
  #[tokio::test]
  async fn test_named_tab_uses_selected_servarr_route_and_network_events() {
    let (network_tx, mut network_rx) = mpsc::channel(500);
    let mut app = App::new(
      network_tx,
      AppConfig {
        radarr: Some(vec![ServarrConfig {
          name: Some("Movies".to_owned()),
          ..ServarrConfig::default()
        }]),
        sonarr: Some(vec![ServarrConfig {
          name: Some("Shows".to_owned()),
          ..ServarrConfig::default()
        }]),
        ..AppConfig::default()
      },
      CancellationToken::new(),
    );
    assert!(app.server_tabs.select_tab_by_title("Shows"));
    assert_eq!(app.get_current_route(), ActiveSonarrBlock::Series.into());
    app.on_tick().await;
    assert_eq!(
      network_rx.recv().await.unwrap(),
      SonarrEvent::GetQualityProfiles.into()
    );
  }
  #[test]
  fn test_reset_cancellation_token() {
    let mut app = App {
      is_loading: true,
      should_refresh: false,
-      ..App::default()
+      ..App::test_default()
    };
    app.cancellation_token.cancel();
@@ -171,7 +219,7 @@ mod tests {
  fn test_reset_tick_count() {
    let mut app = App {
      tick_count: 2,
-      ..App::default()
+      ..App::test_default()
    };
    app.reset_tick_count();
@@ -190,7 +238,9 @@ mod tests {
      ..SonarrData::default()
    };
    let data = Data {
      lidarr_data: LidarrData::default(),
      radarr_data,
      readarr_data: ReadarrData::default(),
      sonarr_data,
    };
    let mut app = App {
@@ -198,7 +248,7 @@ mod tests {
      error: "Test error".to_owned().into(),
      is_first_render: false,
      data,
-      ..App::default()
+      ..App::test_default()
    };
    app.reset();
@@ -212,7 +262,7 @@ mod tests {
  #[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));
@@ -231,7 +281,7 @@ mod tests {
    let mut app = App {
      tick_until_poll: 2,
      network_tx: Some(sync_network_tx),
-      ..App::default()
+      ..App::test_default()
    };
    assert_eq!(app.tick_count, 0);
@@ -247,6 +297,25 @@ mod tests {
    assert_eq!(app.tick_count, 0);
  }
  #[test]
  fn test_on_ui_scroll_tick() {
    let mut app = App {
      scroll_interval: Duration::ZERO,
      ..App::default()
    };
    app.on_ui_scroll_tick();
    assert!(app.should_text_scroll);
    app.on_ui_scroll_tick();
    assert!(app.should_text_scroll);
    app.scroll_interval = Duration::from_secs(60);
    app.last_scroll = Instant::now();
    app.on_ui_scroll_tick();
    assert!(!app.should_text_scroll);
  }
  #[tokio::test]
  async fn test_on_tick_first_render() {
    let (sync_network_tx, mut sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
@@ -255,7 +324,7 @@ mod tests {
      tick_until_poll: 2,
      network_tx: Some(sync_network_tx),
      is_first_render: true,
-      ..App::default()
+      ..App::test_default()
    };
    assert_eq!(app.tick_count, 0);
@@ -276,7 +345,7 @@ mod tests {
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
@@ -309,7 +378,7 @@ mod tests {
      tick_until_poll: 2,
      tick_count: 2,
      is_routing: true,
-      ..App::default()
+      ..App::test_default()
    };
    app.on_tick().await;
@@ -322,7 +391,7 @@ mod tests {
      tick_until_poll: 2,
      tick_count: 2,
      should_refresh: true,
-      ..App::default()
+      ..App::test_default()
    };
    app.on_tick().await;
@@ -333,18 +402,417 @@ mod tests {
  fn test_app_config_default() {
    let app_config = AppConfig::default();
-    assert!(app_config.radarr.is_none());
+    assert_none!(app_config.radarr);
-    assert!(app_config.sonarr.is_none());
+    assert_none!(app_config.sonarr);
  }
  #[test]
  fn test_servarr_config_default() {
    let servarr_config = ServarrConfig::default();
-    assert_eq!(servarr_config.host, Some("localhost".to_string()));
+    assert_none!(servarr_config.name);
-    assert_eq!(servarr_config.port, None);
+    assert_some_eq_x!(&servarr_config.host, "localhost");
-    assert_eq!(servarr_config.uri, None);
+    assert_none!(servarr_config.port);
-    assert!(servarr_config.api_token.is_empty());
+    assert_none!(servarr_config.uri);
-    assert_eq!(servarr_config.ssl_cert_path, None);
+    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);
  }
 }
@@ -1,20 +1,45 @@
-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::readarr::readarr_context_clues::ReadarrContextClueProvider;
 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; 3] = [
+pub struct ServarrContextClueProvider;
 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),
      Route::Readarr(_, _) => ReadarrContextClueProvider::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,
@@ -24,6 +49,7 @@ pub static SERVARR_CONTEXT_CLUES: [ContextClue; 3] = [
    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] =
@@ -78,6 +104,18 @@ pub static INDEXERS_CONTEXT_CLUES: [ContextClue; 6] = [
  ),
 ];
 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"),
@@ -88,3 +126,8 @@ pub static SYSTEM_CONTEXT_CLUES: [ContextClue; 5] = [
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
 ];
 pub static SYSTEM_TASKS_CONTEXT_CLUES: [ContextClue; 2] = [
  (DEFAULT_KEYBINDINGS.submit, "start task"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
@@ -1,212 +1,326 @@
 #[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,
-    DOWNLOADS_CONTEXT_CLUES, INDEXERS_CONTEXT_CLUES, ROOT_FOLDERS_CONTEXT_CLUES,
+    ContextClueProvider, DOWNLOADS_CONTEXT_CLUES, HISTORY_CONTEXT_CLUES, INDEXERS_CONTEXT_CLUES,
-    SERVARR_CONTEXT_CLUES, SYSTEM_CONTEXT_CLUES,
+    ROOT_FOLDERS_CONTEXT_CLUES, SERVARR_CONTEXT_CLUES, SYSTEM_CONTEXT_CLUES,
    SYSTEM_TASKS_CONTEXT_CLUES, ServarrContextClueProvider,
  };
-  use crate::app::{context_clues::build_context_clue_string, key_binding::DEFAULT_KEYBINDINGS};
+  use crate::app::{App, key_binding::DEFAULT_KEYBINDINGS};
-
+  use crate::models::servarr_data::ActiveKeybindingBlock;
-  #[test]
+  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
-  fn test_build_context_clue_string() {
+  use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
-    let test_context_clues_array = [
+  use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
      (DEFAULT_KEYBINDINGS.add, "add"),
      (DEFAULT_KEYBINDINGS.delete, "delete"),
    ];
    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.next_servarr);
+      &(DEFAULT_KEYBINDINGS.up, "scroll up")
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.next_servarr.desc);
+    );
-
+    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.previous_servarr);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.previous_servarr.desc);
+    assert_some_eq_x!(
-
+      servarr_context_clues_iter.next(),
-    let (key_binding, description) = servarr_context_clues_iter.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.left, "previous tab")
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.quit);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.quit.desc);
+      servarr_context_clues_iter.next(),
-    assert_eq!(servarr_context_clues_iter.next(), None);
+      &(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(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.esc.desc);
+    );
-    assert_eq!(bare_popup_context_clues_iter.next(), None);
+    assert_none!(bare_popup_context_clues_iter.next());
  }
  #[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_some_eq_x!(
-
+      downloads_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) = downloads_context_clues_iter.next().unwrap();
+      )
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+      downloads_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
-    let (key_binding, description) = downloads_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+      downloads_context_clues_iter.next(),
-    assert_str_eq!(*description, "update downloads");
+      &(DEFAULT_KEYBINDINGS.update, "update downloads")
-    assert_eq!(downloads_context_clues_iter.next(), None);
+    );
    assert_none!(downloads_context_clues_iter.next());
  }
  #[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_some_eq_x!(
-
+      blocklist_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) = blocklist_context_clues_iter.next().unwrap();
+      )
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
+      blocklist_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+      blocklist_context_clues_iter.next(),
-    assert_str_eq!(*description, "details");
+      &(DEFAULT_KEYBINDINGS.submit, "details")
-
+    );
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      blocklist_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = blocklist_context_clues_iter.next().unwrap();
+      blocklist_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.clear, "clear blocklist")
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.clear);
+    );
-    assert_str_eq!(*description, "clear blocklist");
+    assert_none!(blocklist_context_clues_iter.next());
    assert_eq!(blocklist_context_clues_iter.next(), None);
  }
  #[test]
  fn test_confirmation_prompt_context_clues() {
    let mut confirmation_prompt_context_clues_iter = CONFIRMATION_PROMPT_CONTEXT_CLUES.iter();
-    let (key_binding, description) = confirmation_prompt_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      confirmation_prompt_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.confirm);
+      &(DEFAULT_KEYBINDINGS.confirm, "submit")
-    assert_str_eq!(*description, "submit");
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = confirmation_prompt_context_clues_iter.next().unwrap();
+      confirmation_prompt_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.esc, "cancel")
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    );
-    assert_str_eq!(*description, "cancel");
+    assert_none!(confirmation_prompt_context_clues_iter.next());
    assert_eq!(confirmation_prompt_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_some_eq_x!(
-
+      root_folders_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) = root_folders_context_clues_iter.next().unwrap();
+      root_folders_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+    assert_some_eq_x!(
-
+      root_folders_context_clues_iter.next(),
-    let (key_binding, description) = root_folders_context_clues_iter.next().unwrap();
+      &(
-
+        DEFAULT_KEYBINDINGS.refresh,
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+        DEFAULT_KEYBINDINGS.refresh.desc
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+      )
-    assert_eq!(root_folders_context_clues_iter.next(), None);
+    );
    assert_none!(root_folders_context_clues_iter.next());
  }
  #[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_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());
  }
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+  #[test]
-    assert_str_eq!(*description, "edit indexer");
+  fn test_history_context_clues() {
    let mut history_context_clues_iter = HISTORY_CONTEXT_CLUES.iter();
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(
-
+      history_context_clues_iter.next(),
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.settings);
+      &(DEFAULT_KEYBINDINGS.submit, "details")
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.settings.desc);
+    );
-
+    assert_some_eq_x!(
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
+      history_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+    );
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+    assert_some_eq_x!(
-
+      history_context_clues_iter.next(),
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
-
+    );
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.test);
+    assert_some_eq_x!(
-    assert_str_eq!(*description, "test indexer");
+      history_context_clues_iter.next(),
-
+      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
-    let (key_binding, description) = indexers_context_clues_iter.next().unwrap();
+    );
-
+    assert_some_eq_x!(
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.test_all);
+      history_context_clues_iter.next(),
-    assert_str_eq!(*description, "test all indexers");
+      &(
-
+        DEFAULT_KEYBINDINGS.refresh,
-    let (key_binding, description) = indexers_context_clues_iter.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!(
-    assert_eq!(indexers_context_clues_iter.next(), None);
+      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();
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
+    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());
  }
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.tasks);
+  #[test]
-    assert_str_eq!(*description, "open tasks");
+  fn test_system_tasks_context_clues() {
    let mut system_tasks_context_clues_iter = SYSTEM_TASKS_CONTEXT_CLUES.iter();
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
+    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());
  }
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.events);
+  #[test]
-    assert_str_eq!(*description, "open events");
+  fn test_servarr_context_clue_provider_delegates_to_radarr_provider() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
+    let context_clues = ServarrContextClueProvider::get_context_clues(&mut app);
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.logs);
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES,);
-    assert_str_eq!(*description, "open logs");
+  }
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
+  #[test]
  fn test_servarr_context_clue_provider_delegates_to_sonarr_provider() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveSonarrBlock::SystemTasks.into());
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+    let context_clues = ServarrContextClueProvider::get_context_clues(&mut app);
    assert_str_eq!(*description, "open updates");
-    let (key_binding, description) = system_context_clues_iter.next().unwrap();
+    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES,);
  }
-    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+  #[test]
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+  fn test_servarr_context_clue_provider_delegates_to_readarr_provider() {
-    assert_eq!(system_context_clues_iter.next(), None);
+    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::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);
  }
 }
@@ -14,6 +14,8 @@ generate_keybindings! {
  down,
  left,
  right,
  pg_down,
  pg_up,
  backspace,
  next_servarr,
  previous_servarr,
@@ -21,9 +23,11 @@ generate_keybindings! {
  search,
  auto_search,
  settings,
  help,
  filter,
  sort,
  edit,
  view,
  logs,
  tasks,
  test,
@@ -44,128 +48,208 @@ 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'),
    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",
  },
  view: KeyBinding {
    key: Key::Char('v'),
    alt: None,
    desc: "view",
  },
  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",
  },
  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)
  };
 }
@@ -3,46 +3,91 @@ 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.next_servarr, Key::Tab, "next servarr")]
+  #[case(DEFAULT_KEYBINDINGS.pg_up, Key::PgUp, Some(Key::Ctrl('u')), "page up")]
-  #[case(DEFAULT_KEYBINDINGS.previous_servarr, Key::BackTab, "previous servarr")]
+  #[case(DEFAULT_KEYBINDINGS.backspace, Key::Backspace, Some(Key::Ctrl('h')), "backspace")]
-  #[case(DEFAULT_KEYBINDINGS.clear, Key::Char('c'), "clear")]
+  #[case(DEFAULT_KEYBINDINGS.next_servarr, Key::Tab, None, "next servarr")]
-  #[case(DEFAULT_KEYBINDINGS.auto_search, Key::Char('S'), "auto search")]
+  #[case(DEFAULT_KEYBINDINGS.previous_servarr, Key::BackTab, None, "previous servarr")]
-  #[case(DEFAULT_KEYBINDINGS.search, Key::Char('s'), "search")]
+  #[case(DEFAULT_KEYBINDINGS.clear, Key::Char('c'), None, "clear")]
-  #[case(DEFAULT_KEYBINDINGS.settings, Key::Char('S'), "settings")]
+  #[case(DEFAULT_KEYBINDINGS.auto_search, Key::Char('S'), None, "auto search")]
-  #[case(DEFAULT_KEYBINDINGS.filter, Key::Char('f'), "filter")]
+  #[case(DEFAULT_KEYBINDINGS.search, Key::Char('s'), None, "search")]
-  #[case(DEFAULT_KEYBINDINGS.sort, Key::Char('o'), "sort")]
+  #[case(DEFAULT_KEYBINDINGS.settings, Key::Char('S'), None, "settings")]
-  #[case(DEFAULT_KEYBINDINGS.edit, Key::Char('e'), "edit")]
+  #[case(DEFAULT_KEYBINDINGS.help, Key::Char('?'), None, "show/hide keybindings")]
-  #[case(DEFAULT_KEYBINDINGS.events, Key::Char('e'), "events")]
+  #[case(DEFAULT_KEYBINDINGS.filter, Key::Char('f'), None, "filter")]
-  #[case(DEFAULT_KEYBINDINGS.logs, Key::Char('l'), "logs")]
+  #[case(DEFAULT_KEYBINDINGS.sort, Key::Char('o'), None, "sort")]
-  #[case(DEFAULT_KEYBINDINGS.tasks, Key::Char('t'), "tasks")]
+  #[case(DEFAULT_KEYBINDINGS.edit, Key::Char('e'), None, "edit")]
-  #[case(DEFAULT_KEYBINDINGS.test, Key::Char('t'), "test")]
+  #[case(DEFAULT_KEYBINDINGS.view, Key::Char('v'), None, "view")]
-  #[case(DEFAULT_KEYBINDINGS.test_all, Key::Char('T'), "test all")]
+  #[case(DEFAULT_KEYBINDINGS.events, Key::Char('e'), None, "events")]
-  #[case(DEFAULT_KEYBINDINGS.toggle_monitoring, Key::Char('m'), "toggle monitoring")]
+  #[case(DEFAULT_KEYBINDINGS.logs, Key::Char('L'), None, "logs")]
-  #[case(DEFAULT_KEYBINDINGS.refresh, Key::Ctrl('r'), "refresh")]
+  #[case(DEFAULT_KEYBINDINGS.tasks, Key::Char('t'), None, "tasks")]
-  #[case(DEFAULT_KEYBINDINGS.update, Key::Char('u'), "update")]
+  #[case(DEFAULT_KEYBINDINGS.test, Key::Char('t'), None, "test")]
-  #[case(DEFAULT_KEYBINDINGS.home, Key::Home, "home")]
+  #[case(DEFAULT_KEYBINDINGS.test_all, Key::Char('T'), None, "test all")]
-  #[case(DEFAULT_KEYBINDINGS.end, Key::End, "end")]
+  #[case(DEFAULT_KEYBINDINGS.toggle_monitoring, Key::Char('m'), None, "toggle monitoring")]
-  #[case(DEFAULT_KEYBINDINGS.delete, Key::Delete, "delete")]
+  #[case(DEFAULT_KEYBINDINGS.refresh, Key::Ctrl('r'), None, "refresh")]
-  #[case(DEFAULT_KEYBINDINGS.submit, Key::Enter, "submit")]
+  #[case(DEFAULT_KEYBINDINGS.update, Key::Char('u'), None, "update")]
-  #[case(DEFAULT_KEYBINDINGS.confirm, Key::Ctrl('s'), "submit")]
+  #[case(DEFAULT_KEYBINDINGS.home, Key::Home, None, "home")]
-  #[case(DEFAULT_KEYBINDINGS.quit, Key::Char('q'), "quit")]
+  #[case(DEFAULT_KEYBINDINGS.end, Key::End, None, "end")]
-  #[case(DEFAULT_KEYBINDINGS.esc, Key::Esc, "close")]
+  #[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));
  }
 }
@@ -0,0 +1,242 @@
 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,
  ARTIST_OVERVIEW_BLOCKS, ActiveLidarrBlock, DELETE_ALBUM_BLOCKS, DELETE_ARTIST_BLOCKS,
  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; 9] = [
  (
    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.view, "view overview"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static ARTIST_OVERVIEW_CONTEXT_CLUES: [ContextClue; 2] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.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 ARTIST_OVERVIEW_BLOCKS.contains(&active_lidarr_block) => {
        Some(&ARTIST_OVERVIEW_CONTEXT_CLUES)
      }
      _ 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)
      }
      _ if DELETE_ARTIST_BLOCKS.contains(&active_lidarr_block)
        || DELETE_ALBUM_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(),
    }
  }
 }
@@ -0,0 +1,658 @@
 #[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,
    ARTIST_OVERVIEW_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.view, "view overview")
    );
    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_artist_overview_context_clues() {
    let mut artist_overview_context_clues_iter = ARTIST_OVERVIEW_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      artist_overview_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      artist_overview_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(artist_overview_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_artist_overview_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveLidarrBlock::ArtistOverview.into());
    let context_clues = LidarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &ARTIST_OVERVIEW_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);
  }
  #[rstest]
  fn test_lidarr_context_clue_provider_confirmation_prompt_context_clues_delete_artist_blocks(
    #[values(
      ActiveLidarrBlock::DeleteArtistPrompt,
      ActiveLidarrBlock::DeleteArtistConfirmPrompt,
      ActiveLidarrBlock::DeleteArtistToggleAddListExclusion,
      ActiveLidarrBlock::DeleteArtistToggleDeleteFile
    )]
    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);
  }
  #[rstest]
  fn test_lidarr_context_clue_provider_confirmation_prompt_context_clues_delete_album_blocks(
    #[values(
      ActiveLidarrBlock::DeleteAlbumPrompt,
      ActiveLidarrBlock::DeleteAlbumConfirmPrompt,
      ActiveLidarrBlock::DeleteAlbumToggleAddListExclusion,
      ActiveLidarrBlock::DeleteAlbumToggleDeleteFile
    )]
    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);
  }
 }
@@ -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(5).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, 5).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, 5);
  }
  #[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);
  }
 }
@@ -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;
  }
 }
@@ -1,26 +1,37 @@
-use std::process;
+use anyhow::{Error, Result, anyhow};
 use anyhow::{anyhow, Error};
 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::time::{Duration, Instant};
 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::readarr::readarr_data::{ActiveReadarrBlock, ReadarrData};
 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 readarr;
 pub mod sonarr;
 pub struct App<'a> {
@@ -29,20 +40,23 @@ pub struct App<'a> {
  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 scroll_interval: Duration,
  pub last_scroll: Instant,
  pub tick_count: u64,
  pub should_text_scroll: bool,
  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 cli_mode: bool,
  pub config: AppConfig,
  pub data: Data<'a>,
 }
-impl<'a> App<'a> {
+impl App<'_> {
  pub fn new(
    network_tx: Sender<NetworkEvent>,
    config: AppConfig,
@@ -50,35 +64,112 @@ impl<'a> App<'a> {
  ) -> Self {
    let mut server_tabs = Vec::new();
-    if config.radarr.is_some() {
+    if let Some(radarr_configs) = config.radarr {
-      server_tabs.push(TabRoute {
+      let mut unnamed_idx = 0;
-        title: "Radarr",
+      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(),
        help: format!(
          "<↑↓> scroll | ←→ change tab | {}  ",
          build_context_clue_string(&SERVARR_CONTEXT_CLUES)
        ),
          contextual_help: None,
          config: Some(radarr_config),
        }
      });
      server_tabs.extend(radarr_tabs);
    }
-    if config.sonarr.is_some() {
+    if let Some(sonarr_configs) = config.sonarr {
-      server_tabs.push(TabRoute {
+      let mut unnamed_idx = 0;
-        title: "Sonarr",
+      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(),
        help: format!(
          "<↑↓> scroll | ←→ change tab | {}  ",
          build_context_clue_string(&SERVARR_CONTEXT_CLUES)
        ),
          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);
    }
    if let Some(readarr_configs) = config.readarr {
      let mut unnamed_idx = 0;
      let readarr_tabs = readarr_configs.into_iter().map(|readarr_config| {
        let name = if let Some(name) = readarr_config.name.clone() {
          name
        } else {
          unnamed_idx += 1;
          format!("Readarr {unnamed_idx}")
        };
        TabRoute {
          title: name,
          route: ActiveReadarrBlock::Authors.into(),
          contextual_help: None,
          config: Some(readarr_config),
        }
      });
      server_tabs.extend(readarr_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(server_tabs),
+      server_tabs: TabState::new(weight_sorted_tabs),
      ..App::default()
    }
  }
@@ -90,19 +181,28 @@ impl<'a> App<'a> {
      self.is_loading = true;
    }
-    if let Some(network_tx) = &self.network_tx {
+    if let Some(network_tx) = &self.network_tx
-      if let Err(e) = network_tx.send(action).await {
+      && let Err(e) = network_tx.send(action).await
    {
      self.is_loading = false;
      error!("Failed to send event. {e:?}");
      self.handle_error(anyhow!(e));
    }
  }
  }
  pub fn reset_tick_count(&mut self) {
    self.tick_count = 0;
  }
  pub fn on_ui_scroll_tick(&mut self) {
    if self.last_scroll.elapsed() >= self.scroll_interval {
      self.should_text_scroll = true;
      self.last_scroll = Instant::now();
    } else {
      self.should_text_scroll = false;
    }
  }
  #[allow(dead_code)]
  pub fn reset(&mut self) {
    self.reset_tick_count();
@@ -118,10 +218,15 @@ impl<'a> App<'a> {
  }
  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)
      || self.is_routing
      || self.should_refresh
    {
      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,
        Route::Readarr(active_readarr_block, _) => self.readarr_on_tick(active_readarr_block).await,
        _ => (),
      }
@@ -158,90 +263,168 @@ impl<'a> App<'a> {
  }
  pub fn get_current_route(&self) -> Route {
-    *self
+    self
      .navigation_stack
      .last()
-      .unwrap_or(&self.server_tabs.tabs.first().unwrap().route)
+      .copied()
      .unwrap_or_else(|| self.server_tabs.get_active_route())
  }
 }
-impl<'a> Default for App<'a> {
+impl Default for App<'_> {
  fn default() -> Self {
    App {
      navigation_stack: Vec::new(),
      network_tx: None,
      cancellation_token: CancellationToken::new(),
      keymapping_table: None,
      error: HorizontallyScrollableText::default(),
      notification: None,
      is_first_render: true,
-      server_tabs: TabState::new(vec![
+      server_tabs: TabState::new(Vec::new()),
        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: ActiveSonarrBlock::Series.into(),
          help: format!(
            "<↑↓> scroll | ←→ change tab | {}  ",
            build_context_clue_string(&SERVARR_CONTEXT_CLUES)
          ),
          contextual_help: None,
        },
      ]),
      tick_until_poll: 400,
-      ticks_until_scroll: 4,
+      scroll_interval: Duration::from_millis(100),
      last_scroll: Instant::now(),
      tick_count: 0,
      should_text_scroll: false,
      is_loading: false,
      is_routing: false,
      should_refresh: false,
-      should_ignore_quit_key: false,
+      ignore_special_keys_for_textbox_input: false,
      cli_mode: false,
      config: AppConfig::default(),
      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()),
        },
        TabRoute {
          title: "Readarr".to_owned(),
          route: ActiveReadarrBlock::Authors.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(),
        readarr_data: ReadarrData::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()),
        },
        TabRoute {
          title: "Readarr".to_owned(),
          route: ActiveReadarrBlock::Authors.into(),
          contextual_help: None,
          config: Some(ServarrConfig::default()),
        },
      ]),
      ..App::default()
    }
  }
  pub fn get_navigation_stack_depth(&self) -> usize {
    self.navigation_stack.len()
  }
 }
 #[derive(Default)]
 pub struct Data<'a> {
  pub lidarr_data: LidarrData<'a>,
  pub radarr_data: RadarrData<'a>,
  pub readarr_data: ReadarrData<'a>,
  pub sonarr_data: SonarrData<'a>,
 }
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct AppConfig {
-  pub radarr: Option<ServarrConfig>,
+  pub theme: Option<String>,
-  pub sonarr: Option<ServarrConfig>,
+  pub lidarr: Option<Vec<ServarrConfig>>,
  pub radarr: Option<Vec<ServarrConfig>>,
  pub readarr: Option<Vec<ServarrConfig>>,
  pub sonarr: Option<Vec<ServarrConfig>>,
 }
 impl AppConfig {
-  pub fn validate(&self) {
+  pub fn validate(&self, config_path: &str) {
-    if self.radarr.is_none() && self.sonarr.is_none() {
+    if self.lidarr.is_none()
-      log_and_print_error(
+      && self.radarr.is_none()
-        "No Servarr configuration provided in the specified configuration file".to_owned(),
+      && self.sonarr.is_none()
-      );
+      && self.readarr.is_none()
    {
      log_and_print_error(format!(
        "No Servarrs are configured in the file: {config_path}"
      ));
      process::exit(1);
    }
-    if let Some(radarr_config) = &self.radarr {
+    if let Some(radarr_configs) = &self.radarr {
-      radarr_config.validate();
+      radarr_configs.iter().for_each(|config| config.validate());
    }
-    if let Some(sonarr_config) = &self.sonarr {
+    if let Some(sonarr_configs) = &self.sonarr {
-      sonarr_config.validate();
+      sonarr_configs.iter().for_each(|config| config.validate());
    }
    if let Some(lidarr_configs) = &self.lidarr {
      lidarr_configs.iter().for_each(|config| config.validate());
    }
    if let Some(readarr_configs) = &self.readarr {
      readarr_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!(
-        "{} configuration missing; Unable to run any {} commands.",
+        "{servarr} configuration missing; Unable to run any {servarr} commands."
        servarr, servarr
      ))
    };
    match command {
@@ -253,18 +436,74 @@ impl AppConfig {
        msg("Sonarr");
        process::exit(1);
      }
      Command::Lidarr(_) if self.lidarr.is_none() => {
        msg("Lidarr");
        process::exit(1);
      }
      Command::Readarr(_) if self.readarr.is_none() => {
        msg("Readarr");
        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();
      }
    }
    if let Some(readarr_configs) = self.readarr.as_mut() {
      for readarr_config in readarr_configs {
        readarr_config.post_process_initialization();
      }
    }
  }
 }
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[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>,
-  pub api_token: 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 {
@@ -273,22 +512,184 @@ impl ServarrConfig {
      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,
-      api_token: "".to_string(),
+      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);
+  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()
 }
@@ -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 => {
@@ -40,7 +40,7 @@ impl<'a> App<'a> {
      }
      ActiveRadarrBlock::Downloads => {
        self
-          .dispatch_network_event(RadarrEvent::GetDownloads.into())
+          .dispatch_network_event(RadarrEvent::GetDownloads(500).into())
          .await;
      }
      ActiveRadarrBlock::RootFolders => {
@@ -59,7 +59,12 @@ impl<'a> App<'a> {
          .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 => {
@@ -157,12 +162,9 @@ impl<'a> App<'a> {
  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;
      }
    }
  }
@@ -188,7 +190,7 @@ impl<'a> App<'a> {
      }
    }
-    if self.tick_count % self.tick_until_poll == 0 {
+    if self.tick_count.is_multiple_of(self.tick_until_poll) {
      self.refresh_radarr_metadata().await;
    }
  }
@@ -204,7 +206,7 @@ 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())
@@ -231,7 +233,7 @@ impl<'a> App<'a> {
  }
  async fn extract_movie_id(&self) -> i64 {
-    self.data.radarr_data.movies.current_selection().clone().id
+    self.data.radarr_data.movies.current_selection().id
  }
  async fn extract_movie_search_query(&self) -> String {
@@ -246,12 +248,6 @@ impl<'a> App<'a> {
  }
  async fn extract_radarr_indexer_id(&self) -> i64 {
-    self
+    self.data.radarr_data.indexers.current_selection().id
      .data
      .radarr_data
      .indexers
      .current_selection()
      .clone()
      .id
  }
 }
@@ -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, DELETE_MOVIE_BLOCKS, 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),
@@ -49,7 +62,7 @@ pub static MOVIE_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
  (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,
@@ -61,24 +74,71 @@ pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 6] = [
    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] = [
  (DEFAULT_KEYBINDINGS.submit, "start task"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static COLLECTION_DETAILS_CONTEXT_CLUES: [ContextClue; 3] = [
  (DEFAULT_KEYBINDINGS.submit, "show overview/add movie"),
  (DEFAULT_KEYBINDINGS.edit, "edit collection"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub(in crate::app) struct RadarrContextClueProvider;
 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)
      }
      _ if DELETE_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(),
    }
  }
 }
@@ -1,114 +1,119 @@
 #[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, COLLECTIONS_CONTEXT_CLUES,
+    ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES, COLLECTION_DETAILS_CONTEXT_CLUES,
-    COLLECTION_DETAILS_CONTEXT_CLUES, LIBRARY_CONTEXT_CLUES,
+    COLLECTIONS_CONTEXT_CLUES, LIBRARY_CONTEXT_CLUES, MANUAL_MOVIE_SEARCH_CONTEXT_CLUES,
-    MANUAL_MOVIE_SEARCH_CONTEXTUAL_CONTEXT_CLUES, MANUAL_MOVIE_SEARCH_CONTEXT_CLUES,
+    MOVIE_DETAILS_CONTEXT_CLUES, RadarrContextClueProvider,
    MOVIE_DETAILS_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);
  }
@@ -116,30 +121,32 @@ mod tests {
  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.auto_search);
+      &(
-    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.auto_search.desc);
+        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);
  }
@@ -147,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.auto_search);
    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.auto_search.desc);
    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]
@@ -201,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);
  }
@@ -217,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);
  }
@@ -233,20 +226,275 @@ 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.edit);
+    );
-    assert_str_eq!(*description, "edit collection");
+    assert_some_eq_x!(
-
+      collection_details_context_clues_iter.next(),
-    let (key_binding, description) = collection_details_context_clues_iter.next().unwrap();
+      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
-
+    );
    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
    assert_str_eq!(*description, 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_confirmation_prompt_context_clues_delete_movie_blocks(
    #[values(
      ActiveRadarrBlock::DeleteMoviePrompt,
      ActiveRadarrBlock::DeleteMovieConfirmPrompt,
      ActiveRadarrBlock::DeleteMovieToggleAddListExclusion,
      ActiveRadarrBlock::DeleteMovieToggleDeleteFile
    )]
    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);
  }
 }
@@ -3,15 +3,16 @@ mod tests {
  use pretty_assertions::assert_eq;
  use tokio::sync::mpsc;
  use crate::app::radarr::ActiveRadarrBlock;
  use crate::app::App;
  use crate::app::radarr::ActiveRadarrBlock;
  use crate::models::radarr_models::{
-    AddMovieBody, AddMovieOptions, Collection, CollectionMovie, Credit, Movie, RadarrRelease,
+    AddMovieBody, AddMovieOptions, Collection, CollectionMovie, Credit, MinimumAvailability, Movie,
    MovieMonitor, RadarrRelease,
  };
  use crate::models::servarr_data::radarr::modals::MovieDetailsModal;
  use crate::models::servarr_models::Indexer;
  use crate::network::radarr_network::RadarrEvent;
  use crate::network::NetworkEvent;
  use crate::network::radarr_network::RadarrEvent;
  #[tokio::test]
  async fn test_dispatch_by_blocklist_block() {
@@ -88,13 +89,13 @@ mod tests {
      tmdb_id: 1234,
      title: "Test".to_owned(),
      root_folder_path: "/nfs2".to_owned(),
-      minimum_availability: "announced".to_owned(),
+      minimum_availability: MinimumAvailability::Announced,
      monitored: true,
      quality_profile_id: 2222,
      tags: vec![1, 2],
      tag_input_string: None,
      add_options: AddMovieOptions {
-        monitor: "movieOnly".to_owned(),
+        monitor: MovieMonitor::MovieOnly,
        search_for_movie: true,
      },
    };
@@ -140,7 +141,24 @@ mod tests {
    assert!(app.is_loading);
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.radarr_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_radarr_block(&ActiveRadarrBlock::History)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
      RadarrEvent::GetHistory(500).into()
    );
    assert!(!app.data.radarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
@@ -186,7 +204,7 @@ mod tests {
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.radarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
@@ -467,7 +485,7 @@ mod tests {
  #[tokio::test]
  async fn test_dispatch_by_cast_crew_blocks_cast_and_crew_non_empty() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
      let mut movie_details_modal = MovieDetailsModal::default();
@@ -511,7 +529,7 @@ mod tests {
  #[tokio::test]
  async fn test_dispatch_by_manual_search_block_movie_releases_non_empty() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    let mut movie_details_modal = MovieDetailsModal::default();
    movie_details_modal
      .movie_releases
@@ -531,7 +549,7 @@ mod tests {
  async fn test_dispatch_by_manual_search_block_is_loading() {
    let mut app = App {
      is_loading: true,
-      ..App::default()
+      ..App::test_default()
    };
    app
@@ -545,7 +563,7 @@ mod tests {
  #[tokio::test]
  async fn test_check_for_radarr_prompt_action_no_prompt_confirm() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    app.data.radarr_data.prompt_confirm = false;
    app.check_for_radarr_prompt_action().await;
@@ -591,7 +609,7 @@ mod tests {
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
@@ -625,7 +643,7 @@ mod tests {
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
@@ -650,7 +668,7 @@ mod tests {
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.radarr_data.prompt_confirm);
  }
@@ -675,7 +693,7 @@ mod tests {
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(app.should_refresh);
    assert!(!app.data.radarr_data.prompt_confirm);
@@ -692,7 +710,7 @@ mod tests {
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(app.is_loading);
    assert!(app.should_refresh);
@@ -722,14 +740,14 @@ mod tests {
    );
    assert_eq!(
      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
+      RadarrEvent::GetDownloads(500).into()
    );
    assert!(app.is_loading);
  }
  #[tokio::test]
  async fn test_populate_movie_collection_table_unfiltered() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    app.data.radarr_data.collections.set_items(vec![Collection {
      movies: Some(vec![CollectionMovie::default()]),
      ..Collection::default()
@@ -742,7 +760,7 @@ mod tests {
  #[tokio::test]
  async fn test_populate_movie_collection_table_filtered() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    app
      .data
      .radarr_data
@@ -759,7 +777,7 @@ mod tests {
  #[tokio::test]
  async fn test_extract_movie_id() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(vec![Movie {
      id: 1,
      ..Movie::default()
@@ -770,7 +788,7 @@ mod tests {
  #[tokio::test]
  async fn test_extract_radarr_indexer_id() {
-    let mut app = App::default();
+    let mut app = App::test_default();
    app.data.radarr_data.indexers.set_items(vec![Indexer {
      id: 1,
      ..Indexer::default()
@@ -785,7 +803,7 @@ mod tests {
      network_tx: Some(sync_network_tx),
      tick_count: 1,
      is_first_render: false,
-      ..App::default()
+      ..App::test_default()
    };
    app.data.radarr_data.prompt_confirm = true;
@@ -0,0 +1,248 @@
 use super::App;
 use crate::{
  models::servarr_data::readarr::readarr_data::ActiveReadarrBlock,
  network::readarr_network::ReadarrEvent,
 };
 pub mod readarr_context_clues;
 #[cfg(test)]
 #[path = "readarr_tests.rs"]
 mod readarr_tests;
 impl App<'_> {
  pub(super) async fn dispatch_by_readarr_block(
    &mut self,
    active_readarr_block: &ActiveReadarrBlock,
  ) {
    match active_readarr_block {
      ActiveReadarrBlock::Authors => {
        self
          .dispatch_network_event(ReadarrEvent::GetQualityProfiles.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetMetadataProfiles.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetTags.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::ListAuthors.into())
          .await;
      }
      ActiveReadarrBlock::Blocklist => {
        self
          .dispatch_network_event(ReadarrEvent::GetBlocklist.into())
          .await;
      }
      ActiveReadarrBlock::Downloads => {
        self
          .dispatch_network_event(ReadarrEvent::GetDownloads(500).into())
          .await;
      }
      ActiveReadarrBlock::AuthorDetails => {
        self
          .dispatch_network_event(ReadarrEvent::GetBooks(self.extract_author_id().await).into())
          .await;
      }
      ActiveReadarrBlock::AuthorHistory => {
        self
          .dispatch_network_event(
            ReadarrEvent::GetAuthorHistory(self.extract_author_id().await).into(),
          )
          .await;
      }
      ActiveReadarrBlock::ManualAuthorSearch => {
        if self.data.readarr_data.author_releases.is_empty() {
          self
            .dispatch_network_event(
              ReadarrEvent::GetAuthorReleases(self.extract_author_id().await).into(),
            )
            .await;
        }
      }
      ActiveReadarrBlock::BookDetails => {
        let book_id = self.extract_book_id().await;
        self
          .dispatch_network_event(ReadarrEvent::GetBookEditions(book_id).into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetBookFiles(book_id).into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetDownloads(500).into())
          .await;
      }
      ActiveReadarrBlock::BookHistory => {
        if !self.data.readarr_data.books.is_empty() {
          self
            .dispatch_network_event(
              ReadarrEvent::GetBookHistory(
                self.extract_author_id().await,
                self.extract_book_id().await,
              )
              .into(),
            )
            .await;
        }
      }
      ActiveReadarrBlock::ManualBookSearch => {
        match self.data.readarr_data.book_details_modal.as_ref() {
          Some(book_details_modal) if book_details_modal.book_releases.is_empty() => {
            self
              .dispatch_network_event(
                ReadarrEvent::GetBookReleases(self.extract_book_id().await).into(),
              )
              .await;
          }
          _ => (),
        }
      }
      ActiveReadarrBlock::AddAuthorSearchResults => {
        self
          .dispatch_network_event(
            ReadarrEvent::SearchNewAuthor(self.extract_add_new_author_search_query().await).into(),
          )
          .await;
      }
      ActiveReadarrBlock::History => {
        self
          .dispatch_network_event(ReadarrEvent::GetHistory(500).into())
          .await
      }
      ActiveReadarrBlock::RootFolders => {
        self
          .dispatch_network_event(ReadarrEvent::GetRootFolders.into())
          .await;
      }
      ActiveReadarrBlock::Indexers => {
        self
          .dispatch_network_event(ReadarrEvent::GetTags.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetIndexers.into())
          .await;
      }
      ActiveReadarrBlock::AllIndexerSettingsPrompt => {
        self
          .dispatch_network_event(ReadarrEvent::GetAllIndexerSettings.into())
          .await;
      }
      ActiveReadarrBlock::TestIndexer => {
        self
          .dispatch_network_event(
            ReadarrEvent::TestIndexer(self.extract_readarr_indexer_id().await).into(),
          )
          .await;
      }
      ActiveReadarrBlock::TestAllIndexers => {
        self
          .dispatch_network_event(ReadarrEvent::TestAllIndexers.into())
          .await;
      }
      ActiveReadarrBlock::System => {
        self
          .dispatch_network_event(ReadarrEvent::GetTasks.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetQueuedEvents.into())
          .await;
        self
          .dispatch_network_event(ReadarrEvent::GetLogs(500).into())
          .await;
      }
      ActiveReadarrBlock::SystemUpdates => {
        self
          .dispatch_network_event(ReadarrEvent::GetUpdates.into())
          .await;
      }
      _ => (),
    }
    self.check_for_readarr_prompt_action().await;
    self.reset_tick_count();
  }
  async fn extract_add_new_author_search_query(&self) -> String {
    self
      .data
      .readarr_data
      .add_author_search
      .as_ref()
      .expect("Add author search is empty")
      .text
      .clone()
  }
  async fn extract_author_id(&self) -> i64 {
    self.data.readarr_data.authors.current_selection().id
  }
  async fn extract_book_id(&self) -> i64 {
    self.data.readarr_data.books.current_selection().id
  }
  async fn extract_readarr_indexer_id(&self) -> i64 {
    self.data.readarr_data.indexers.current_selection().id
  }
  async fn check_for_readarr_prompt_action(&mut self) {
    if self.data.readarr_data.prompt_confirm {
      self.data.readarr_data.prompt_confirm = false;
      if let Some(readarr_event) = self.data.readarr_data.prompt_confirm_action.take() {
        self.dispatch_network_event(readarr_event.into()).await;
        self.should_refresh = true;
      }
    }
  }
  pub(super) async fn readarr_on_tick(&mut self, active_readarr_block: ActiveReadarrBlock) {
    if self.is_first_render {
      self.refresh_readarr_metadata().await;
      self.dispatch_by_readarr_block(&active_readarr_block).await;
      self.is_first_render = false;
      return;
    }
    if self.should_refresh {
      self.dispatch_by_readarr_block(&active_readarr_block).await;
      self.refresh_readarr_metadata().await;
    }
    if self.is_routing {
      if !self.should_refresh {
        self.cancellation_token.cancel();
      } else {
        self.dispatch_by_readarr_block(&active_readarr_block).await;
      }
    }
    if self.tick_count.is_multiple_of(self.tick_until_poll) {
      self.refresh_readarr_metadata().await;
    }
  }
  async fn refresh_readarr_metadata(&mut self) {
    self
      .dispatch_network_event(ReadarrEvent::GetQualityProfiles.into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetMetadataProfiles.into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetTags.into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetRootFolders.into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetDownloads(500).into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetDiskSpace.into())
      .await;
    self
      .dispatch_network_event(ReadarrEvent::GetStatus.into())
      .await;
  }
 }
@@ -0,0 +1,230 @@
 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::readarr::readarr_data::{
  ADD_AUTHOR_BLOCKS, ADD_ROOT_FOLDER_BLOCKS, AUTHOR_DETAILS_BLOCKS, AUTHOR_OVERVIEW_BLOCKS,
  ActiveReadarrBlock, BOOK_DETAILS_BLOCKS, DELETE_AUTHOR_BLOCKS, DELETE_BOOK_BLOCKS,
  EDIT_AUTHOR_BLOCKS, EDIT_INDEXER_BLOCKS, EDITION_DETAILS_BLOCKS, INDEXER_SETTINGS_BLOCKS,
 };
 #[cfg(test)]
 #[path = "readarr_context_clues_tests.rs"]
 mod readarr_context_clues_tests;
 pub static AUTHORS_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_AUTHOR_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
  (DEFAULT_KEYBINDINGS.submit, "details"),
  (DEFAULT_KEYBINDINGS.esc, "edit search"),
 ];
 pub static AUTHOR_DETAILS_CONTEXT_CLUES: [ContextClue; 9] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.edit, "edit author"),
  (DEFAULT_KEYBINDINGS.delete, "delete book"),
  (
    DEFAULT_KEYBINDINGS.toggle_monitoring,
    "toggle book 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.view, "view overview"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static AUTHOR_OVERVIEW_CONTEXT_CLUES: [ContextClue; 2] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static AUTHOR_HISTORY_CONTEXT_CLUES: [ContextClue; 9] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.edit, "edit author"),
  (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_AUTHOR_SEARCH_CONTEXT_CLUES: [ContextClue; 7] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.edit, "edit author"),
  (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 BOOK_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
  (
    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, "edition details"),
 ];
 pub static BOOK_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 BOOK_FILE_CONTEXT_CLUES: [ContextClue; 3] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.delete, "delete book file"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static MANUAL_BOOK_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 EDITION_DETAILS_CONTEXT_CLUES: [ContextClue; 2] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
  ),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub(in crate::app) struct ReadarrContextClueProvider;
 impl ContextClueProvider for ReadarrContextClueProvider {
  fn get_context_clues(app: &mut App<'_>) -> Option<&'static [ContextClue]> {
    let Route::Readarr(active_readarr_block, _context_option) = app.get_current_route() else {
      panic!("ReadarrContextClueProvider::get_context_clues called with non-Readarr route");
    };
    match active_readarr_block {
      _ if AUTHOR_DETAILS_BLOCKS.contains(&active_readarr_block) => app
        .data
        .readarr_data
        .author_info_tabs
        .get_active_route_contextual_help(),
      _ if AUTHOR_OVERVIEW_BLOCKS.contains(&active_readarr_block) => {
        Some(&AUTHOR_OVERVIEW_CONTEXT_CLUES)
      }
      _ if BOOK_DETAILS_BLOCKS.contains(&active_readarr_block) => app
        .data
        .readarr_data
        .book_details_modal
        .as_ref()
        .expect("book_details_modal is empty")
        .book_details_tabs
        .get_active_route_contextual_help(),
      _ if EDITION_DETAILS_BLOCKS.contains(&active_readarr_block) => {
        Some(&EDITION_DETAILS_CONTEXT_CLUES)
      }
      ActiveReadarrBlock::AddAuthorSearchInput
      | ActiveReadarrBlock::AddAuthorEmptySearchResults
      | ActiveReadarrBlock::TestAllIndexers
      | ActiveReadarrBlock::SystemLogs
      | ActiveReadarrBlock::SystemUpdates => Some(&BARE_POPUP_CONTEXT_CLUES),
      _ if EDIT_AUTHOR_BLOCKS.contains(&active_readarr_block)
        || EDIT_INDEXER_BLOCKS.contains(&active_readarr_block)
        || INDEXER_SETTINGS_BLOCKS.contains(&active_readarr_block)
        || ADD_ROOT_FOLDER_BLOCKS.contains(&active_readarr_block) =>
      {
        Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES)
      }
      _ if DELETE_AUTHOR_BLOCKS.contains(&active_readarr_block)
        || DELETE_BOOK_BLOCKS.contains(&active_readarr_block) =>
      {
        Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES)
      }
      ActiveReadarrBlock::AddAuthorPrompt
      | ActiveReadarrBlock::AddAuthorSelectMonitor
      | ActiveReadarrBlock::AddAuthorSelectMonitorNewItems
      | ActiveReadarrBlock::AddAuthorSelectQualityProfile
      | ActiveReadarrBlock::AddAuthorSelectMetadataProfile
      | ActiveReadarrBlock::AddAuthorSelectRootFolder
      | ActiveReadarrBlock::AddAuthorTagsInput
      | ActiveReadarrBlock::AddAuthorAlreadyInLibrary => Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES),
      _ if ADD_AUTHOR_BLOCKS.contains(&active_readarr_block) => {
        Some(&ADD_AUTHOR_SEARCH_RESULTS_CONTEXT_CLUES)
      }
      ActiveReadarrBlock::SystemTasks => Some(&SYSTEM_TASKS_CONTEXT_CLUES),
      _ => app
        .data
        .readarr_data
        .main_tabs
        .get_active_route_contextual_help(),
    }
  }
 }
@@ -0,0 +1,628 @@
 #[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::readarr::readarr_context_clues::{
    ADD_AUTHOR_SEARCH_RESULTS_CONTEXT_CLUES, AUTHOR_DETAILS_CONTEXT_CLUES,
    AUTHOR_HISTORY_CONTEXT_CLUES, AUTHOR_OVERVIEW_CONTEXT_CLUES, AUTHORS_CONTEXT_CLUES,
    BOOK_DETAILS_CONTEXT_CLUES, BOOK_FILE_CONTEXT_CLUES, BOOK_HISTORY_CONTEXT_CLUES,
    EDITION_DETAILS_CONTEXT_CLUES, MANUAL_AUTHOR_SEARCH_CONTEXT_CLUES,
    MANUAL_BOOK_SEARCH_CONTEXT_CLUES, ReadarrContextClueProvider,
  };
  use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
  use crate::models::servarr_data::readarr::modals::BookDetailsModal;
  use crate::models::servarr_data::readarr::readarr_data::{
    ADD_ROOT_FOLDER_BLOCKS, ActiveReadarrBlock, EDIT_AUTHOR_BLOCKS, EDIT_INDEXER_BLOCKS,
    INDEXER_SETTINGS_BLOCKS, ReadarrData,
  };
  use rstest::rstest;
  #[test]
  fn test_authors_context_clues() {
    let mut authors_context_clues_iter = AUTHORS_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.toggle_monitoring,
        DEFAULT_KEYBINDINGS.toggle_monitoring.desc
      )
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.update, "update all")
    );
    assert_some_eq_x!(
      authors_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, "cancel filter")
    );
    assert_none!(authors_context_clues_iter.next());
  }
  #[test]
  fn test_author_details_context_clues() {
    let mut author_details_context_clues_iter = AUTHOR_DETAILS_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc,
      )
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.edit, "edit author")
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.delete, "delete book")
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.toggle_monitoring,
        "toggle book monitoring",
      )
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc,
      )
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.view, "view overview")
    );
    assert_some_eq_x!(
      author_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(author_details_context_clues_iter.next());
  }
  #[test]
  fn test_author_overview_context_clues() {
    let mut author_overview_context_clues_iter = AUTHOR_OVERVIEW_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      author_overview_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      author_overview_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(author_overview_context_clues_iter.next());
  }
  #[test]
  fn test_add_author_search_results_context_clues() {
    let mut add_author_search_results_context_clues_iter =
      ADD_AUTHOR_SEARCH_RESULTS_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      add_author_search_results_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "details")
    );
    assert_some_eq_x!(
      add_author_search_results_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, "edit search")
    );
    assert_none!(add_author_search_results_context_clues_iter.next());
  }
  #[test]
  #[should_panic(
    expected = "ReadarrContextClueProvider::get_context_clues called with non-Readarr route"
  )]
  fn test_readarr_context_clue_provider_get_context_clues_non_readarr_route() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveRadarrBlock::default().into());
    ReadarrContextClueProvider::get_context_clues(&mut app);
  }
  #[test]
  fn test_author_history_context_clues() {
    let mut author_history_context_clues_iter = AUTHOR_HISTORY_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.edit, "edit author")
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "details")
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc
      )
    );
    assert_some_eq_x!(
      author_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
    );
    assert_none!(author_history_context_clues_iter.next());
  }
  #[test]
  fn test_manual_author_search_context_clues() {
    let mut manual_author_search_context_clues_iter = MANUAL_AUTHOR_SEARCH_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.edit, "edit author")
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "details")
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc)
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc
      )
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
    );
    assert_some_eq_x!(
      manual_author_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(manual_author_search_context_clues_iter.next());
  }
  #[test]
  fn test_book_details_context_clues() {
    let mut book_details_context_clues_iter = BOOK_DETAILS_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      book_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      book_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
    );
    assert_some_eq_x!(
      book_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc
      )
    );
    assert_some_eq_x!(
      book_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_some_eq_x!(
      book_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "edition details")
    );
    assert_none!(book_details_context_clues_iter.next());
  }
  #[test]
  fn test_book_history_context_clues() {
    let mut book_history_context_clues_iter = BOOK_HISTORY_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc)
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc)
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc
      )
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "details")
    );
    assert_some_eq_x!(
      book_history_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, "cancel filter/close")
    );
    assert_none!(book_history_context_clues_iter.next());
  }
  #[test]
  fn test_book_file_context_clues() {
    let mut book_file_context_clues_iter = BOOK_FILE_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      book_file_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      book_file_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.delete, "delete book file")
    );
    assert_some_eq_x!(
      book_file_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(book_file_context_clues_iter.next());
  }
  #[test]
  fn test_manual_book_search_context_clues() {
    let mut manual_book_search_context_clues_iter = MANUAL_BOOK_SEARCH_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      manual_book_search_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      manual_book_search_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.auto_search,
        DEFAULT_KEYBINDINGS.auto_search.desc
      )
    );
    assert_some_eq_x!(
      manual_book_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc)
    );
    assert_some_eq_x!(
      manual_book_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.submit, "details")
    );
    assert_some_eq_x!(
      manual_book_search_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(manual_book_search_context_clues_iter.next());
  }
  #[test]
  fn test_edition_details_context_clues() {
    let mut edition_details_context_clues_iter = EDITION_DETAILS_CONTEXT_CLUES.iter();
    assert_some_eq_x!(
      edition_details_context_clues_iter.next(),
      &(
        DEFAULT_KEYBINDINGS.refresh,
        DEFAULT_KEYBINDINGS.refresh.desc
      )
    );
    assert_some_eq_x!(
      edition_details_context_clues_iter.next(),
      &(DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc)
    );
    assert_none!(edition_details_context_clues_iter.next());
  }
  #[rstest]
  #[case(0, ActiveReadarrBlock::AuthorDetails, &AUTHOR_DETAILS_CONTEXT_CLUES)]
  #[case(1, ActiveReadarrBlock::AuthorHistory, &AUTHOR_HISTORY_CONTEXT_CLUES)]
  #[case(2, ActiveReadarrBlock::ManualAuthorSearch, &MANUAL_AUTHOR_SEARCH_CONTEXT_CLUES)]
  fn test_readarr_context_clue_provider_author_info_tabs(
    #[case] index: usize,
    #[case] active_readarr_block: ActiveReadarrBlock,
    #[case] expected_context_clues: &[ContextClue],
  ) {
    let mut app = App::test_default();
    app.data.readarr_data = ReadarrData::default();
    app.data.readarr_data.author_info_tabs.set_index(index);
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, expected_context_clues);
  }
  #[rstest]
  #[case(0, ActiveReadarrBlock::BookDetails, &BOOK_DETAILS_CONTEXT_CLUES)]
  #[case(1, ActiveReadarrBlock::BookHistory, &BOOK_HISTORY_CONTEXT_CLUES)]
  #[case(2, ActiveReadarrBlock::BookFileInfo, &BOOK_FILE_CONTEXT_CLUES)]
  #[case(3, ActiveReadarrBlock::ManualBookSearch, &MANUAL_BOOK_SEARCH_CONTEXT_CLUES)]
  fn test_readarr_context_clue_provider_book_details_tabs(
    #[case] index: usize,
    #[case] active_readarr_block: ActiveReadarrBlock,
    #[case] expected_context_clues: &[ContextClue],
  ) {
    let mut app = App::test_default();
    let mut book_details_modal = BookDetailsModal::default();
    book_details_modal.book_details_tabs.set_index(index);
    let readarr_data = ReadarrData {
      book_details_modal: Some(book_details_modal),
      ..ReadarrData::default()
    };
    app.data.readarr_data = readarr_data;
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, expected_context_clues);
  }
  #[test]
  fn test_readarr_context_clue_provider_book_edition_details_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::BookEditionDetails.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &EDITION_DETAILS_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_author_overview_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::AuthorOverview.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &AUTHOR_OVERVIEW_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_authors_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::Authors.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &AUTHORS_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_authors_sort_prompt_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::AuthorsSortPrompt.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &AUTHORS_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_search_authors_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::SearchAuthors.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &AUTHORS_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_filter_authors_block() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::FilterAuthors.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &AUTHORS_CONTEXT_CLUES);
  }
  #[rstest]
  fn test_readarr_context_clue_provider_bare_popup_context_clues(
    #[values(
      ActiveReadarrBlock::AddAuthorSearchInput,
      ActiveReadarrBlock::AddAuthorEmptySearchResults,
      ActiveReadarrBlock::TestAllIndexers,
      ActiveReadarrBlock::SystemLogs,
      ActiveReadarrBlock::SystemUpdates
    )]
    active_readarr_block: ActiveReadarrBlock,
  ) {
    let mut app = App::test_default();
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &BARE_POPUP_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_confirmation_prompt_popup_clues_edit_indexer_blocks() {
    let mut blocks = EDIT_AUTHOR_BLOCKS.to_vec();
    blocks.extend(ADD_ROOT_FOLDER_BLOCKS);
    blocks.extend(INDEXER_SETTINGS_BLOCKS);
    blocks.extend(EDIT_INDEXER_BLOCKS);
    for active_readarr_block in blocks {
      let mut app = App::test_default();
      app.push_navigation_stack(active_readarr_block.into());
      let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
      assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
    }
  }
  #[test]
  fn test_readarr_context_clue_provider_add_author_search_results_context_clues() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::AddAuthorSearchResults.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &ADD_AUTHOR_SEARCH_RESULTS_CONTEXT_CLUES);
  }
  #[rstest]
  fn test_readarr_context_clue_provider_confirmation_prompt_context_clues_add_author_blocks(
    #[values(
      ActiveReadarrBlock::AddAuthorPrompt,
      ActiveReadarrBlock::AddAuthorSelectMonitor,
      ActiveReadarrBlock::AddAuthorSelectMonitorNewItems,
      ActiveReadarrBlock::AddAuthorSelectQualityProfile,
      ActiveReadarrBlock::AddAuthorSelectMetadataProfile,
      ActiveReadarrBlock::AddAuthorSelectRootFolder,
      ActiveReadarrBlock::AddAuthorTagsInput,
      ActiveReadarrBlock::AddAuthorAlreadyInLibrary
    )]
    active_readarr_block: ActiveReadarrBlock,
  ) {
    let mut app = App::test_default();
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
  }
  #[rstest]
  fn test_readarr_context_clue_provider_confirmation_prompt_context_clues_delete_author_blocks(
    #[values(
      ActiveReadarrBlock::DeleteAuthorPrompt,
      ActiveReadarrBlock::DeleteAuthorConfirmPrompt,
      ActiveReadarrBlock::DeleteAuthorToggleAddListExclusion,
      ActiveReadarrBlock::DeleteAuthorToggleDeleteFile
    )]
    active_readarr_block: ActiveReadarrBlock,
  ) {
    let mut app = App::test_default();
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
  }
  #[rstest]
  fn test_readarr_context_clue_provider_confirmation_prompt_context_clues_delete_book_blocks(
    #[values(
      ActiveReadarrBlock::DeleteBookPrompt,
      ActiveReadarrBlock::DeleteBookConfirmPrompt,
      ActiveReadarrBlock::DeleteBookToggleAddListExclusion,
      ActiveReadarrBlock::DeleteBookToggleDeleteFile
    )]
    active_readarr_block: ActiveReadarrBlock,
  ) {
    let mut app = App::test_default();
    app.push_navigation_stack(active_readarr_block.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &CONFIRMATION_PROMPT_CONTEXT_CLUES);
  }
  #[test]
  fn test_readarr_context_clue_provider_system_tasks_clues() {
    let mut app = App::test_default();
    app.push_navigation_stack(ActiveReadarrBlock::SystemTasks.into());
    let context_clues = ReadarrContextClueProvider::get_context_clues(&mut app);
    assert_some_eq_x!(context_clues, &SYSTEM_TASKS_CONTEXT_CLUES);
  }
 }
@@ -0,0 +1,798 @@
 #[cfg(test)]
 mod tests {
  use crate::app::App;
  use crate::models::readarr_models::{Author, Book, ReadarrRelease};
  use crate::models::servarr_data::readarr::modals::BookDetailsModal;
  use crate::models::servarr_data::readarr::readarr_data::ActiveReadarrBlock;
  use crate::models::servarr_models::Indexer;
  use crate::network::NetworkEvent;
  use crate::network::readarr_network::ReadarrEvent;
  use pretty_assertions::{assert_eq, assert_str_eq};
  use tokio::sync::mpsc;
  #[tokio::test]
  async fn test_dispatch_by_readarr_block_authors() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Authors)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetQualityProfiles.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetMetadataProfiles.into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTags.into());
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::ListAuthors.into());
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_readarr_block_author_details() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::AuthorDetails)
      .await;
    assert!(app.is_loading);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetBooks(1).into());
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Blocklist)
      .await;
    assert!(app.is_loading);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetBlocklist.into());
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_author_history_block() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::AuthorHistory)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetAuthorHistory(1).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_manual_author_search_block() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::ManualAuthorSearch)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetAuthorReleases(1).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_manual_author_search_block_author_releases_non_empty() {
    let mut app = App::test_default();
    app
      .data
      .readarr_data
      .author_releases
      .set_items(vec![ReadarrRelease::default()]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::ManualAuthorSearch)
      .await;
    assert!(!app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_book_details_block() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app.data.readarr_data.books.set_items(vec![Book {
      id: 2,
      ..Book::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::BookDetails)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetBookEditions(2).into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetBookFiles(2).into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_book_history_block() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app.data.readarr_data.books.set_items(vec![Book {
      id: 2,
      ..Book::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::BookHistory)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetBookHistory(1, 2).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_book_history_block_no_op_when_books_table_is_empty() {
    let (tx, _) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::BookHistory)
      .await;
    assert!(!app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_manual_book_search_block() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    app.data.readarr_data.books.set_items(vec![Book {
      id: 2,
      ..Book::default()
    }]);
    app.data.readarr_data.book_details_modal = Some(BookDetailsModal::default());
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::ManualBookSearch)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetBookReleases(2).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_manual_book_search_block_is_loading() {
    let mut app = App {
      is_loading: true,
      ..App::test_default()
    };
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::ManualBookSearch)
      .await;
    assert!(app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_manual_book_search_block_book_releases_non_empty() {
    let mut app = App::test_default();
    let mut book_details_modal = BookDetailsModal::default();
    book_details_modal
      .book_releases
      .set_items(vec![ReadarrRelease::default()]);
    app.data.readarr_data.book_details_modal = Some(book_details_modal);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::ManualBookSearch)
      .await;
    assert!(!app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_book_edition_details_block_does_not_dispatch() {
    let mut app = App::test_default_fully_populated();
    app.data.readarr_data.prompt_confirm = false;
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::BookEditionDetails)
      .await;
    assert!(!app.is_loading);
    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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Downloads)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_readarr_block_add_author_search_results() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.add_author_search = Some("test author".into());
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::AddAuthorSearchResults)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::SearchNewAuthor("test author".to_owned()).into()
    );
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::History)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetHistory(500).into()
    );
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::RootFolders)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetRootFolders.into()
    );
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Indexers)
      .await;
    assert!(app.is_loading);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTags.into());
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetIndexers.into());
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::AllIndexerSettingsPrompt)
      .await;
    assert!(app.is_loading);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetAllIndexerSettings.into()
    );
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.indexers.set_items(vec![Indexer {
      id: 3,
      ..Indexer::default()
    }]);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::TestIndexer)
      .await;
    assert!(app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::TestIndexer(3).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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::TestAllIndexers)
      .await;
    assert!(app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::System)
      .await;
    assert!(app.is_loading);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTasks.into());
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetQueuedEvents.into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetLogs(500).into());
    assert!(!app.data.readarr_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.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::SystemUpdates)
      .await;
    assert!(app.is_loading);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetUpdates.into());
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_readarr_block_resets_the_tick_count() {
    let mut app = App {
      tick_count: 2,
      ..App::test_default()
    };
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Authors)
      .await;
    assert_eq!(app.tick_count, 0);
  }
  #[tokio::test]
  async fn test_dispatch_by_readarr_block_clears_the_pending_prompt_confirmation() {
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app
      .dispatch_by_readarr_block(&ActiveReadarrBlock::Authors)
      .await;
    assert!(!app.data.readarr_data.prompt_confirm);
    assert!(!app.should_refresh);
  }
  #[tokio::test]
  async fn test_check_for_readarr_prompt_action_no_prompt_confirm() {
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = false;
    app.check_for_readarr_prompt_action().await;
    assert!(!app.data.readarr_data.prompt_confirm);
    assert!(!app.should_refresh);
  }
  #[tokio::test]
  async fn test_check_for_readarr_prompt_action_with_no_prompt_confirm_action() {
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.check_for_readarr_prompt_action().await;
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_none!(app.data.readarr_data.prompt_confirm_action);
    assert!(!app.should_refresh);
  }
  #[tokio::test]
  async fn test_check_for_readarr_prompt_action() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.data.readarr_data.prompt_confirm_action = Some(ReadarrEvent::GetStatus);
    app.check_for_readarr_prompt_action().await;
    assert!(!app.data.readarr_data.prompt_confirm);
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetStatus.into());
    assert!(app.should_refresh);
    assert_eq!(app.data.readarr_data.prompt_confirm_action, None);
  }
  #[tokio::test]
  async fn test_readarr_refresh_metadata() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.is_routing = true;
    app.refresh_readarr_metadata().await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetQualityProfiles.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetMetadataProfiles.into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTags.into());
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetRootFolders.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetDiskSpace.into());
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetStatus.into());
    assert!(app.is_loading);
  }
  #[tokio::test]
  async fn test_readarr_on_tick_first_render() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.is_first_render = true;
    app.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetQualityProfiles.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetMetadataProfiles.into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTags.into());
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetRootFolders.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetDiskSpace.into());
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetStatus.into());
    assert!(app.is_loading);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert!(!app.is_first_render);
  }
  #[tokio::test]
  async fn test_readarr_on_tick_routing() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_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.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(!app.data.readarr_data.prompt_confirm);
  }
  #[tokio::test]
  async fn test_readarr_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.readarr_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.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert!(app.cancellation_token.is_cancelled());
  }
  #[tokio::test]
  async fn test_readarr_on_tick_should_refresh() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.should_refresh = true;
    app.is_first_render = false;
    app.tick_count = 1;
    app.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(app.should_refresh);
    assert!(!app.data.readarr_data.prompt_confirm);
  }
  #[tokio::test]
  async fn test_readarr_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.readarr_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.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(app.is_loading);
    assert!(app.should_refresh);
    assert!(!app.data.readarr_data.prompt_confirm);
    assert!(!app.cancellation_token.is_cancelled());
  }
  #[tokio::test]
  async fn test_readarr_on_tick_network_tick_frequency() {
    let (tx, mut rx) = mpsc::channel::<NetworkEvent>(500);
    let mut app = App::test_default();
    app.data.readarr_data.prompt_confirm = true;
    app.network_tx = Some(tx);
    app.is_first_render = false;
    app.tick_count = 2;
    app.tick_until_poll = 2;
    app.readarr_on_tick(ActiveReadarrBlock::Downloads).await;
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetQualityProfiles.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetMetadataProfiles.into()
    );
    assert_eq!(rx.recv().await.unwrap(), ReadarrEvent::GetTags.into());
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetRootFolders.into()
    );
    assert_eq!(
      rx.recv().await.unwrap(),
      ReadarrEvent::GetDownloads(500).into()
    );
    assert!(app.is_loading);
  }
  #[tokio::test]
  async fn test_extract_add_new_author_search_query() {
    let app = App::test_default_fully_populated();
    let query = app.extract_add_new_author_search_query().await;
    assert_str_eq!(query, "Test Author");
  }
  #[tokio::test]
  #[should_panic(expected = "Add author search is empty")]
  async fn test_extract_add_new_author_search_query_panics_when_the_query_is_not_set() {
    let app = App::test_default();
    app.extract_add_new_author_search_query().await;
  }
  #[tokio::test]
  async fn test_extract_author_id() {
    let mut app = App::test_default();
    app.data.readarr_data.authors.set_items(vec![Author {
      id: 1,
      ..Author::default()
    }]);
    assert_eq!(app.extract_author_id().await, 1);
  }
  #[tokio::test]
  async fn test_extract_book_id() {
    let mut app = App::test_default();
    app.data.readarr_data.books.set_items(vec![Book {
      id: 2,
      ..Book::default()
    }]);
    assert_eq!(app.extract_book_id().await, 2);
  }
  #[tokio::test]
  async fn test_extract_readarr_indexer_id() {
    let mut app = App::test_default();
    app.data.readarr_data.indexers.set_items(vec![Indexer {
      id: 3,
      ..Indexer::default()
    }]);
    assert_eq!(app.extract_readarr_indexer_id().await, 3);
  }
 }
@@ -11,7 +11,7 @@ pub mod sonarr_context_clues;
 #[path = "sonarr_tests.rs"]
 mod sonarr_tests;
-impl<'a> App<'a> {
+impl App<'_> {
  pub(super) async fn dispatch_by_sonarr_block(&mut self, active_sonarr_block: &ActiveSonarrBlock) {
    match active_sonarr_block {
      ActiveSonarrBlock::Series => {
@@ -53,26 +53,24 @@ impl<'a> App<'a> {
          )
          .await;
        self
-          .dispatch_network_event(SonarrEvent::GetDownloads.into())
+          .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(
+            .dispatch_network_event(SonarrEvent::GetSeasonHistory(series_id, season_number).into())
              SonarrEvent::GetSeasonHistory(self.extract_series_id_season_number_tuple().await)
                .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(self.extract_series_id_season_number_tuple().await)
+                SonarrEvent::GetSeasonReleases(series_id, season_number).into(),
                  .into(),
              )
              .await;
          }
@@ -94,9 +92,10 @@ impl<'a> App<'a> {
          .await;
      }
      ActiveSonarrBlock::ManualEpisodeSearch => {
-        if let Some(season_details_modal) = self.data.sonarr_data.season_details_modal.as_ref() {
+        if let Some(season_details_modal) = self.data.sonarr_data.season_details_modal.as_ref()
-          if let Some(episode_details_modal) = season_details_modal.episode_details_modal.as_ref() {
+          && let Some(episode_details_modal) = season_details_modal.episode_details_modal.as_ref()
-            if episode_details_modal.episode_releases.is_empty() {
+          && episode_details_modal.episode_releases.is_empty()
        {
          self
            .dispatch_network_event(
              SonarrEvent::GetEpisodeReleases(self.extract_episode_id().await).into(),
@@ -104,11 +103,9 @@ impl<'a> App<'a> {
            .await;
        }
      }
        }
      }
      ActiveSonarrBlock::Downloads => {
        self
-          .dispatch_network_event(SonarrEvent::GetDownloads.into())
+          .dispatch_network_event(SonarrEvent::GetDownloads(500).into())
          .await;
      }
      ActiveSonarrBlock::Blocklist => {
@@ -187,12 +184,9 @@ impl<'a> App<'a> {
  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 {
+      if let Some(sonarr_event) = self.data.sonarr_data.prompt_confirm_action.take() {
-        self
+        self.dispatch_network_event(sonarr_event.into()).await;
          .dispatch_network_event(sonarr_event.clone().into())
          .await;
        self.should_refresh = true;
        self.data.sonarr_data.prompt_confirm_action = None;
      }
    }
  }
@@ -218,7 +212,7 @@ impl<'a> App<'a> {
      }
    }
-    if self.tick_count % self.tick_until_poll == 0 {
+    if self.tick_count.is_multiple_of(self.tick_until_poll) {
      self.refresh_sonarr_metadata().await;
    }
  }
@@ -237,7 +231,7 @@ impl<'a> App<'a> {
      .dispatch_network_event(SonarrEvent::GetRootFolders.into())
      .await;
    self
-      .dispatch_network_event(SonarrEvent::GetDownloads.into())
+      .dispatch_network_event(SonarrEvent::GetDownloads(500).into())
      .await;
    self
      .dispatch_network_event(SonarrEvent::GetDiskSpace.into())
@@ -1,4 +1,14 @@
-use crate::app::{context_clues::ContextClue, key_binding::DEFAULT_KEYBINDINGS};
+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, DELETE_SERIES_BLOCKS, EDIT_INDEXER_BLOCKS,
  EDIT_SERIES_BLOCKS, EPISODE_DETAILS_BLOCKS, INDEXER_SETTINGS_BLOCKS, SEASON_DETAILS_BLOCKS,
  SERIES_DETAILS_BLOCKS, SERIES_OVERVIEW_BLOCKS,
 };
 #[cfg(test)]
 #[path = "sonarr_context_clues_tests.rs"]
@@ -9,9 +19,13 @@ pub static ADD_SERIES_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
  (DEFAULT_KEYBINDINGS.esc, "edit search"),
 ];
-pub static SERIES_CONTEXT_CLUES: [ContextClue; 10] = [
+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),
@@ -25,7 +39,7 @@ pub static SERIES_CONTEXT_CLUES: [ContextClue; 10] = [
  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
 ];
-pub static SERIES_DETAILS_CONTEXT_CLUES: [ContextClue; 8] = [
+pub static SERIES_DETAILS_CONTEXT_CLUES: [ContextClue; 9] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
@@ -42,19 +56,16 @@ pub static SERIES_DETAILS_CONTEXT_CLUES: [ContextClue; 8] = [
    DEFAULT_KEYBINDINGS.auto_search,
    DEFAULT_KEYBINDINGS.auto_search.desc,
  ),
  (DEFAULT_KEYBINDINGS.view, "view overview"),
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
-pub static HISTORY_CONTEXT_CLUES: [ContextClue; 6] = [
+pub static SERIES_OVERVIEW_CONTEXT_CLUES: [ContextClue; 2] = [
  (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"),
+  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 pub static SERIES_HISTORY_CONTEXT_CLUES: [ContextClue; 9] = [
@@ -75,12 +86,7 @@ pub static SERIES_HISTORY_CONTEXT_CLUES: [ContextClue; 9] = [
  (DEFAULT_KEYBINDINGS.esc, "cancel filter/close"),
 ];
-pub static SEASON_DETAILS_CONTEXTUAL_CONTEXT_CLUES: [ContextClue; 2] = [
+pub static SEASON_DETAILS_CONTEXT_CLUES: [ContextClue; 7] = [
  (DEFAULT_KEYBINDINGS.submit, "episode details"),
  (DEFAULT_KEYBINDINGS.delete, "delete episode"),
 ];
 pub static SEASON_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
@@ -95,9 +101,11 @@ pub static SEASON_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
    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; 6] = [
+pub static SEASON_HISTORY_CONTEXT_CLUES: [ContextClue; 7] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
@@ -109,10 +117,11 @@ pub static SEASON_HISTORY_CONTEXT_CLUES: [ContextClue; 6] = [
    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; 4] = [
+pub static MANUAL_SEASON_SEARCH_CONTEXT_CLUES: [ContextClue; 5] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
@@ -122,10 +131,11 @@ pub static MANUAL_SEASON_SEARCH_CONTEXT_CLUES: [ContextClue; 4] = [
    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; 4] = [
+pub static MANUAL_EPISODE_SEARCH_CONTEXT_CLUES: [ContextClue; 5] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
    DEFAULT_KEYBINDINGS.refresh.desc,
@@ -135,12 +145,10 @@ pub static MANUAL_EPISODE_SEARCH_CONTEXT_CLUES: [ContextClue; 4] = [
    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 DETAILS_CONTEXTUAL_CONTEXT_CLUES: [ContextClue; 1] =
  [(DEFAULT_KEYBINDINGS.submit, "details")];
 pub static EPISODE_DETAILS_CONTEXT_CLUES: [ContextClue; 3] = [
  (
    DEFAULT_KEYBINDINGS.refresh,
@@ -153,7 +161,85 @@ pub static EPISODE_DETAILS_CONTEXT_CLUES: [ContextClue; 3] = [
  (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
-pub static SYSTEM_TASKS_CONTEXT_CLUES: [ContextClue; 2] = [
+pub static SELECTABLE_EPISODE_DETAILS_CONTEXT_CLUES: [ContextClue; 4] = [
-  (DEFAULT_KEYBINDINGS.submit, "start task"),
+  (
    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 SERIES_OVERVIEW_BLOCKS.contains(&active_sonarr_block) => {
        Some(&SERIES_OVERVIEW_CONTEXT_CLUES)
      }
      _ 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)
      }
      _ if DELETE_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(),
    }
  }
 }
@@ -16,7 +16,7 @@ mod tests {
        },
        sonarr_models::{Season, Series, SonarrRelease},
      },
-      network::{sonarr_network::SonarrEvent, NetworkEvent},
+      network::{NetworkEvent, sonarr_network::SonarrEvent},
    };
    #[tokio::test]
@@ -107,7 +107,7 @@ mod tests {
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(!app.data.sonarr_data.prompt_confirm);
      assert_eq!(app.tick_count, 0);
@@ -132,7 +132,7 @@ mod tests {
      assert!(app.is_loading);
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetSeasonHistory((1, 1)).into()
+        SonarrEvent::GetSeasonHistory(1, 1).into()
      );
      assert!(!app.data.sonarr_data.prompt_confirm);
      assert_eq!(app.tick_count, 0);
@@ -175,7 +175,7 @@ mod tests {
      assert!(app.is_loading);
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetSeasonReleases((1, 1)).into()
+        SonarrEvent::GetSeasonReleases(1, 1).into()
      );
      assert!(!app.data.sonarr_data.prompt_confirm);
      assert_eq!(app.tick_count, 0);
@@ -185,7 +185,7 @@ mod tests {
    async fn test_dispatch_by_manual_season_search_block_is_loading() {
      let mut app = App {
        is_loading: true,
-        ..App::default()
+        ..App::test_default()
      };
      app
@@ -199,7 +199,7 @@ mod tests {
    #[tokio::test]
    async fn test_dispatch_by_manual_season_search_block_season_releases_non_empty() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      let mut season_details_modal = SeasonDetailsModal::default();
      season_details_modal
        .season_releases
@@ -304,7 +304,7 @@ mod tests {
    async fn test_dispatch_by_manual_episode_search_block_is_loading() {
      let mut app = App {
        is_loading: true,
-        ..App::default()
+        ..App::test_default()
      };
      app
@@ -318,7 +318,7 @@ mod tests {
    #[tokio::test]
    async fn test_dispatch_by_manual_episode_search_block_episode_releases_non_empty() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      let mut episode_details_modal = EpisodeDetailsModal::default();
      episode_details_modal
        .episode_releases
@@ -366,7 +366,7 @@ mod tests {
      assert!(app.is_loading);
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(!app.data.sonarr_data.prompt_confirm);
      assert_eq!(app.tick_count, 0);
@@ -554,7 +554,7 @@ mod tests {
    #[tokio::test]
    async fn test_check_for_sonarr_prompt_action_no_prompt_confirm() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.prompt_confirm = false;
      app.check_for_sonarr_prompt_action().await;
@@ -604,7 +604,7 @@ mod tests {
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
@@ -642,7 +642,7 @@ mod tests {
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
@@ -667,7 +667,7 @@ mod tests {
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(!app.data.sonarr_data.prompt_confirm);
    }
@@ -692,7 +692,7 @@ mod tests {
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(app.should_refresh);
      assert!(!app.data.sonarr_data.prompt_confirm);
@@ -709,7 +709,7 @@ mod tests {
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(app.is_loading);
      assert!(app.should_refresh);
@@ -743,14 +743,14 @@ mod tests {
      );
      assert_eq!(
        sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::GetDownloads.into()
+        SonarrEvent::GetDownloads(500).into()
      );
      assert!(app.is_loading);
    }
    #[tokio::test]
    async fn test_populate_seasons_table_unfiltered() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.series.set_items(vec![Series {
        seasons: Some(vec![Season::default()]),
        ..Series::default()
@@ -770,7 +770,7 @@ mod tests {
    #[tokio::test]
    async fn test_populate_seasons_table_filtered() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.series.set_filtered_items(vec![Series {
        seasons: Some(vec![Season::default()]),
        ..Series::default()
@@ -790,7 +790,7 @@ mod tests {
    #[tokio::test]
    async fn test_extract_episode_id() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      let mut season_details_modal = SeasonDetailsModal::default();
      season_details_modal.episodes.set_items(vec![Episode {
        id: 1,
@@ -804,14 +804,14 @@ mod tests {
    #[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::default();
+      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::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.series.set_items(vec![Series {
        id: 1,
        ..Series::default()
@@ -822,7 +822,7 @@ mod tests {
    #[tokio::test]
    async fn test_extract_series_id_season_number_tuple() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.series.set_items(vec![Series {
        id: 1,
        ..Series::default()
@@ -837,7 +837,7 @@ mod tests {
    #[tokio::test]
    async fn test_extract_add_new_series_search_query() {
-      let mut app = App::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.add_series_search = Some("test search".into());
      assert_str_eq!(
@@ -849,14 +849,14 @@ mod tests {
    #[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::default();
+      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::default();
+      let mut app = App::test_default();
      app.data.sonarr_data.indexers.set_items(vec![Indexer {
        id: 1,
        ..Indexer::default()
@@ -871,7 +871,7 @@ mod tests {
        network_tx: Some(sync_network_tx),
        tick_count: 1,
        is_first_render: false,
-        ..App::default()
+        ..App::test_default()
      };
      app.data.sonarr_data.prompt_confirm = true;
@@ -2,30 +2,42 @@
 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::cli::readarr::ReadarrCommand;
  use crate::network::lidarr_network::LidarrEvent;
  use crate::network::readarr_network::ReadarrEvent;
  use crate::{
    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,
      },
      readarr_models::{
        BlocklistItem as ReadarrBlocklistItem, BlocklistResponse as ReadarrBlocklistResponse,
        ReadarrSerdeable,
      },
      sonarr_models::{
        BlocklistItem as SonarrBlocklistItem, BlocklistResponse as SonarrBlocklistResponse,
        SonarrSerdeable,
      },
      Serdeable,
    },
    network::{
-      radarr_network::RadarrEvent, sonarr_network::SonarrEvent, MockNetworkTrait, NetworkEvent,
+      MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent, sonarr_network::SonarrEvent,
    },
    Cli,
  };
  use pretty_assertions::assert_eq;
@@ -33,7 +45,7 @@ mod tests {
  fn test_servarr_subcommand_requires_subcommand(#[values("radarr", "sonarr")] subcommand: &str) {
    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
@@ -45,21 +57,35 @@ 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!(result.is_ok());
+    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_readarr_subcommand_delegates_to_readarr() {
    let result = Cli::command().try_get_matches_from(["managarr", "readarr", "list", "authors"]);
    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
@@ -70,7 +96,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);
  }
@@ -78,7 +104,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]
@@ -136,12 +162,12 @@ 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 clear_blocklist_command = RadarrCommand::ClearBlocklist.into();
    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
-    assert!(result.is_ok());
+    assert_ok!(&result);
  }
  #[tokio::test]
@@ -167,11 +193,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 clear_blocklist_command = SonarrCommand::ClearBlocklist.into();
    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_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);
  }
  #[tokio::test]
  async fn test_cli_handler_delegates_readarr_commands_to_the_readarr_cli_handler() {
    let mut mock_network = MockNetworkTrait::new();
    mock_network
      .expect_handle_network_event()
      .with(eq::<NetworkEvent>(ReadarrEvent::GetBlocklist.into()))
      .times(1)
      .returning(|_| {
        Ok(Serdeable::Readarr(ReadarrSerdeable::BlocklistResponse(
          ReadarrBlocklistResponse {
            records: vec![ReadarrBlocklistItem::default()],
          },
        )))
      });
    mock_network
      .expect_handle_network_event()
      .with(eq::<NetworkEvent>(ReadarrEvent::ClearBlocklist.into()))
      .times(1)
      .returning(|_| {
        Ok(Serdeable::Readarr(ReadarrSerdeable::Value(
          json!({"testResponse": "response"}),
        )))
      });
    let app_arc = Arc::new(Mutex::new(App::test_default()));
    let clear_blocklist_command = ReadarrCommand::ClearBlocklist.into();
    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
    assert_ok!(&result);
  }
 }
@@ -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)
  }
 }
@@ -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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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: 12345,
        minimum_age: 11,
        retention: 29,
        rss_sync_interval: 60,
      };
      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: 5,
              maximum_size: 22222,
              minimum_age: 34,
              retention: 48,
              rss_sync_interval: 90,
            },
          )))
        });
      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(12345),
        minimum_age: Some(11),
        retention: Some(29),
        rss_sync_interval: Some(60),
      };
      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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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);
    }
  }
 }
@@ -0,0 +1,773 @@
 #[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, LidarrTaskName};
    use crate::models::servarr_models::{IndexerSettings, ReleaseDownloadBody};
    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 = ReleaseDownloadBody {
        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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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 = 5;
      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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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()
      );
    }
  }
 }
@@ -0,0 +1,296 @@
 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::LidarrTaskName;
 use crate::models::servarr_models::ReleaseDownloadBody;
 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 = ReleaseDownloadBody { 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)
  }
 }
@@ -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)
  }
 }
@@ -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);
    }
  }
 }
@@ -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)
  }
 }
@@ -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);
    }
  }
 }
@@ -1,15 +1,20 @@
 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 readarr::{ReadarrCliHandler, ReadarrCommand};
 use sonarr::{SonarrCliHandler, SonarrCommand};
 use tokio::sync::Mutex;
 use crate::{app::App, network::NetworkTrait};
 pub mod lidarr;
 pub mod radarr;
 pub mod readarr;
 pub mod sonarr;
 #[cfg(test)]
@@ -24,6 +29,12 @@ pub enum Command {
  #[command(subcommand, about = "Commands for manging your Sonarr instance")]
  Sonarr(SonarrCommand),
  #[command(subcommand, about = "Commands for manging your Lidarr instance")]
  Lidarr(LidarrCommand),
  #[command(subcommand, about = "Commands for managing your Readarr instance")]
  Readarr(ReadarrCommand),
  #[command(
    arg_required_else_help = true,
    about = "Generate shell completions for the Managarr CLI"
@@ -38,6 +49,12 @@ pub enum Command {
    #[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>> {
@@ -61,6 +78,16 @@ pub(crate) async fn handle_command(
        .handle()
        .await?
    }
    Command::Lidarr(lidarr_command) => {
      LidarrCliHandler::with(app, lidarr_command, network)
        .handle()
        .await?
    }
    Command::Readarr(readarr_command) => {
      ReadarrCliHandler::with(app, readarr_command, network)
        .handle()
        .await?
    }
    _ => String::new(),
  };
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use anyhow::Result;
-use clap::{arg, command, ArgAction, Subcommand};
+use clap::{ArgAction, Subcommand};
 use tokio::sync::Mutex;
 use super::RadarrCommand;
@@ -10,7 +10,7 @@ use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
  models::radarr_models::{AddMovieBody, AddMovieOptions, MinimumAvailability, MovieMonitor},
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 #[cfg(test)]
@@ -122,12 +122,12 @@ 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,
          tag_input_string: None,
          add_options: AddMovieOptions {
-            monitor: monitor.to_string(),
+            monitor,
            search_for_movie: !no_search_for_movie,
          },
        };
@@ -1,14 +1,14 @@
 #[cfg(test)]
 mod tests {
-  use clap::{error::ErrorKind, CommandFactory, Parser};
+  use clap::{CommandFactory, Parser, error::ErrorKind};
  use crate::{
    Cli,
    cli::{
      radarr::{add_command_handler::RadarrAddCommand, RadarrCommand},
      Command,
      radarr::{RadarrCommand, add_command_handler::RadarrAddCommand},
    },
    models::radarr_models::{MinimumAvailability, MovieMonitor},
    Cli,
  };
  use pretty_assertions::assert_eq;
@@ -32,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
@@ -52,7 +52,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -72,7 +72,7 @@ mod tests {
        "/test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -92,7 +92,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -117,7 +117,7 @@ mod tests {
        flag,
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -136,7 +136,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -156,7 +156,7 @@ mod tests {
        "test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -177,7 +177,7 @@ mod tests {
        "test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -207,11 +207,12 @@ 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 {
        panic!("Unexpected command type")
      };
      assert_eq!(add_command, expected_args);
    }
    }
    #[test]
    fn test_add_movie_tags_is_repeatable() {
@@ -243,11 +244,12 @@ 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 {
        panic!("Unexpected command type")
      };
      assert_eq!(add_command, expected_args);
    }
    }
    #[test]
    fn test_add_movie_all_args_defined() {
@@ -285,18 +287,19 @@ 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 {
        panic!("Unexpected command type")
      };
      assert_eq!(add_command, expected_args);
    }
    }
    #[test]
    fn test_add_root_folder_requires_arguments() {
      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
@@ -318,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 {
        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
@@ -344,25 +348,26 @@ 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 {
        panic!("Unexpected command type")
      };
      assert_eq!(add_command, expected_args);
    }
  }
  }
  mod handler {
    use std::sync::Arc;
    use crate::{
      app::App,
-      cli::{radarr::add_command_handler::RadarrAddCommandHandler, CliCommandHandler},
+      cli::{CliCommandHandler, radarr::add_command_handler::RadarrAddCommandHandler},
      models::{
        radarr_models::{AddMovieBody, AddMovieOptions, RadarrSerdeable},
        Serdeable,
        radarr_models::{AddMovieBody, AddMovieOptions, RadarrSerdeable},
      },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    use super::*;
@@ -379,12 +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],
        tag_input_string: None,
        add_options: AddMovieOptions {
-          monitor: "movieAndCollection".to_owned(),
+          monitor: MovieMonitor::MovieAndCollection,
          search_for_movie: false,
        },
      };
@@ -400,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(),
@@ -416,7 +421,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -437,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,
      };
@@ -447,7 +452,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -465,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,
      };
@@ -474,7 +479,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -8,7 +8,7 @@ use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
  models::radarr_models::DeleteMovieParams,
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 use super::RadarrCommand;
@@ -1,13 +1,13 @@
 #[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]
@@ -30,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
@@ -52,20 +52,21 @@ 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 {
        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", "radarr", "delete", "download"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -85,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 {
        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
@@ -117,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 {
        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
@@ -147,13 +150,14 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(delete_command, expected_args);
    }
    }
    #[test]
    fn test_delete_movie_all_args_defined() {
@@ -174,20 +178,21 @@ 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 {
        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", "radarr", "delete", "root-folder"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -207,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 {
        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
@@ -232,14 +238,15 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(delete_command, expected_args);
    }
  }
  }
  mod handler {
    use std::sync::Arc;
@@ -251,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]
@@ -276,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,
      };
@@ -289,7 +296,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -307,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 =
@@ -315,7 +322,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -333,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 =
@@ -341,7 +348,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -363,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,
@@ -375,7 +382,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -393,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 =
@@ -401,7 +408,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -419,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 =
@@ -427,7 +434,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -6,15 +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},
  models::{
    Serdeable,
    radarr_models::{
      EditCollectionParams, EditMovieParams, IndexerSettings, MinimumAvailability, RadarrSerdeable,
    },
    servarr_models::EditIndexerParams,
    Serdeable,
  },
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 use super::RadarrCommand;
@@ -379,13 +379,7 @@ 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(),
          };
          self
@@ -1,13 +1,13 @@
 #[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]
@@ -42,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
@@ -60,7 +60,7 @@ mod tests {
        "--disable-allow-hardcoded-subs",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -75,7 +75,7 @@ mod tests {
        "--disable-prefer-indexer-flags",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -99,7 +99,7 @@ mod tests {
        flag,
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -126,12 +126,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_all_indexer_settings_all_arguments_defined() {
@@ -168,19 +169,20 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_collection_requires_arguments() {
      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
@@ -198,7 +200,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -218,7 +220,7 @@ mod tests {
        "--disable-monitoring",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -235,7 +237,7 @@ mod tests {
        "--disable-search-on-add",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -252,7 +254,7 @@ mod tests {
        "test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -270,7 +272,7 @@ mod tests {
        flag,
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -298,12 +300,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_collection_all_arguments_defined() {
@@ -334,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 {
        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
@@ -363,7 +367,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -383,7 +387,7 @@ mod tests {
        "--disable-rss",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -400,7 +404,7 @@ mod tests {
        "--disable-automatic-search",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -417,7 +421,7 @@ mod tests {
        "--disable-interactive-search",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -435,7 +439,7 @@ mod tests {
        "--clear-tags",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -453,7 +457,7 @@ mod tests {
        flag,
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -487,12 +491,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_indexer_tag_argument_is_repeatable() {
@@ -526,12 +531,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_indexer_all_arguments_defined() {
@@ -578,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 {
        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
@@ -607,7 +614,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -627,7 +634,7 @@ mod tests {
        "--disable-monitoring",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -645,7 +652,7 @@ mod tests {
        "--clear-tags",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
    }
@@ -669,7 +676,7 @@ mod tests {
        flag,
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -686,7 +693,7 @@ mod tests {
        "test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -714,12 +721,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_movie_tag_argument_is_repeatable() {
@@ -747,12 +755,13 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
    }
    #[test]
    fn test_edit_movie_all_arguments_defined() {
@@ -787,13 +796,14 @@ 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 {
        panic!("Unexpected command type");
      };
      assert_eq!(edit_command, expected_args);
    }
  }
  }
  mod handler {
    use std::sync::Arc;
@@ -805,31 +815,31 @@ mod tests {
    use crate::{
      app::App,
      cli::{
        radarr::edit_command_handler::{RadarrEditCommand, RadarrEditCommandHandler},
        CliCommandHandler,
        radarr::edit_command_handler::{RadarrEditCommand, RadarrEditCommandHandler},
      },
      models::{
        Serdeable,
        radarr_models::{
          EditCollectionParams, EditMovieParams, IndexerSettings, MinimumAvailability,
          RadarrSerdeable,
        },
        servarr_models::EditIndexerParams,
        Serdeable,
      },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    #[tokio::test]
    async fn test_handle_edit_all_indexer_settings_command() {
      let expected_edit_all_indexer_settings = IndexerSettings {
        allow_hardcoded_subs: true,
-        availability_delay: 1,
+        availability_delay: 19,
        id: 1,
-        maximum_size: 1,
+        maximum_size: 18400,
-        minimum_age: 1,
+        minimum_age: 27,
        prefer_indexer_flags: true,
-        retention: 1,
+        retention: 44,
-        rss_sync_interval: 1,
+        rss_sync_interval: 60,
        whitelisted_hardcoded_subs: "test".into(),
      };
      let mut mock_network = MockNetworkTrait::new();
@@ -843,13 +853,13 @@ mod tests {
          Ok(Serdeable::Radarr(RadarrSerdeable::IndexerSettings(
            IndexerSettings {
              allow_hardcoded_subs: false,
-              availability_delay: 2,
+              availability_delay: 31,
-              id: 1,
+              id: 8,
-              maximum_size: 2,
+              maximum_size: 22750,
-              minimum_age: 2,
+              minimum_age: 52,
              prefer_indexer_flags: false,
-              retention: 2,
+              retention: 66,
-              rss_sync_interval: 2,
+              rss_sync_interval: 90,
              whitelisted_hardcoded_subs: "testing".into(),
            },
          )))
@@ -865,17 +875,17 @@ 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,
-        availability_delay: Some(1),
+        availability_delay: Some(19),
-        maximum_size: Some(1),
+        maximum_size: Some(18400),
-        minimum_age: Some(1),
+        minimum_age: Some(27),
        prefer_indexer_flags: true,
        disable_prefer_indexer_flags: false,
-        retention: Some(1),
+        retention: Some(44),
-        rss_sync_interval: Some(1),
+        rss_sync_interval: Some(60),
        whitelisted_subtitle_tags: Some("test".to_owned()),
      };
@@ -887,20 +897,20 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
    async fn test_handle_edit_all_indexer_settings_command_disable_flags_function_properly() {
      let expected_edit_all_indexer_settings = IndexerSettings {
        allow_hardcoded_subs: false,
-        availability_delay: 1,
+        availability_delay: 19,
        id: 1,
-        maximum_size: 1,
+        maximum_size: 18400,
-        minimum_age: 1,
+        minimum_age: 27,
        prefer_indexer_flags: false,
-        retention: 1,
+        retention: 44,
-        rss_sync_interval: 1,
+        rss_sync_interval: 60,
        whitelisted_hardcoded_subs: "test".into(),
      };
      let mut mock_network = MockNetworkTrait::new();
@@ -914,13 +924,13 @@ mod tests {
          Ok(Serdeable::Radarr(RadarrSerdeable::IndexerSettings(
            IndexerSettings {
              allow_hardcoded_subs: true,
-              availability_delay: 2,
+              availability_delay: 31,
-              id: 1,
+              id: 8,
-              maximum_size: 2,
+              maximum_size: 22750,
-              minimum_age: 2,
+              minimum_age: 52,
              prefer_indexer_flags: true,
-              retention: 2,
+              retention: 66,
-              rss_sync_interval: 2,
+              rss_sync_interval: 90,
              whitelisted_hardcoded_subs: "testing".into(),
            },
          )))
@@ -936,17 +946,17 @@ 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,
-        availability_delay: Some(1),
+        availability_delay: Some(19),
-        maximum_size: Some(1),
+        maximum_size: Some(18400),
-        minimum_age: Some(1),
+        minimum_age: Some(27),
        prefer_indexer_flags: false,
        disable_prefer_indexer_flags: true,
-        retention: Some(1),
+        retention: Some(44),
-        rss_sync_interval: Some(1),
+        rss_sync_interval: Some(60),
        whitelisted_subtitle_tags: Some("test".to_owned()),
      };
@@ -958,21 +968,21 @@ 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,
+        availability_delay: 31,
        id: 1,
-        maximum_size: 2,
+        maximum_size: 22750,
-        minimum_age: 2,
+        minimum_age: 52,
-        prefer_indexer_flags: true,
+        prefer_indexer_flags: false,
-        retention: 2,
+        retention: 66,
-        rss_sync_interval: 2,
+        rss_sync_interval: 90,
        whitelisted_hardcoded_subs: "testing".into(),
      };
      let mut mock_network = MockNetworkTrait::new();
@@ -986,13 +996,13 @@ mod tests {
          Ok(Serdeable::Radarr(RadarrSerdeable::IndexerSettings(
            IndexerSettings {
              allow_hardcoded_subs: true,
-              availability_delay: 2,
+              availability_delay: 31,
-              id: 1,
+              id: 8,
-              maximum_size: 2,
+              maximum_size: 22750,
-              minimum_age: 2,
+              minimum_age: 52,
-              prefer_indexer_flags: true,
+              prefer_indexer_flags: false,
-              retention: 2,
+              retention: 66,
-              rss_sync_interval: 2,
+              rss_sync_interval: 90,
              whitelisted_hardcoded_subs: "testing".into(),
            },
          )))
@@ -1008,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,
@@ -1030,7 +1040,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1055,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,
@@ -1072,7 +1082,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1097,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,
@@ -1114,7 +1124,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1139,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,
@@ -1156,7 +1166,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1187,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()),
@@ -1210,7 +1220,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1241,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()),
@@ -1264,7 +1274,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1295,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()),
@@ -1318,7 +1328,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1345,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,
@@ -1361,7 +1371,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1388,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,
@@ -1404,7 +1414,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -1431,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,
@@ -1447,7 +1457,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -1,13 +1,13 @@
 use std::sync::Arc;
 use anyhow::Result;
-use clap::{command, Subcommand};
+use clap::Subcommand;
 use tokio::sync::Mutex;
 use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 use super::RadarrCommand;
@@ -1,12 +1,12 @@
 #[cfg(test)]
 mod tests {
  use clap::error::ErrorKind;
  use clap::CommandFactory;
  use clap::error::ErrorKind;
  use crate::cli::radarr::get_command_handler::RadarrGetCommand;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::Command;
  use crate::Cli;
  use crate::cli::Command;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::radarr::get_command_handler::RadarrGetCommand;
  use pretty_assertions::assert_eq;
  #[test]
@@ -27,7 +27,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "all-indexer-settings"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -35,7 +35,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "host-config"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -43,7 +43,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "movie-details"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -61,7 +61,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -69,7 +69,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "movie-history"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -87,7 +87,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -95,7 +95,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "security-config"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -103,7 +103,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "system-status"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
@@ -117,11 +117,11 @@ mod tests {
    use crate::{
      app::App,
      cli::{
        radarr::get_command_handler::{RadarrGetCommand, RadarrGetCommandHandler},
        CliCommandHandler,
        radarr::get_command_handler::{RadarrGetCommand, RadarrGetCommandHandler},
      },
-      models::{radarr_models::RadarrSerdeable, Serdeable},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    #[tokio::test]
@@ -138,7 +138,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 get_all_indexer_settings_command = RadarrGetCommand::AllIndexerSettings;
      let result = RadarrGetCommandHandler::with(
@@ -149,7 +149,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -164,7 +164,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 get_host_config_command = RadarrGetCommand::HostConfig;
      let result =
@@ -172,7 +172,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -190,7 +190,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 get_movie_details_command = RadarrGetCommand::MovieDetails { movie_id: 1 };
      let result =
@@ -198,7 +198,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -216,7 +216,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 get_movie_history_command = RadarrGetCommand::MovieHistory { movie_id: 1 };
      let result =
@@ -224,7 +224,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -239,7 +239,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 get_security_config_command = RadarrGetCommand::SecurityConfig;
      let result =
@@ -247,7 +247,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -262,7 +262,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 get_system_status_command = RadarrGetCommand::SystemStatus;
      let result =
@@ -270,7 +270,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -1,13 +1,13 @@
 use std::sync::Arc;
 use anyhow::Result;
-use clap::{command, Subcommand};
+use clap::Subcommand;
 use tokio::sync::Mutex;
 use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 use super::RadarrCommand;
@@ -23,9 +23,17 @@ pub enum RadarrListCommand {
  #[command(about = "List all Radarr collections")]
  Collections,
  #[command(about = "List all active downloads in Radarr")]
-  Downloads,
+  Downloads {
    #[arg(long, help = "How many downloads to fetch", default_value_t = 500)]
    count: u64,
  },
  #[command(about = "List disk space details for all provisioned root folders in Radarr")]
  DiskSpace,
  #[command(about = "Fetch all Radarr history events")]
  History {
    #[arg(long, help = "How many history events to fetch", default_value_t = 500)]
    events: u64,
  },
  #[command(about = "List all Radarr indexers")]
  Indexers,
  #[command(about = "Fetch Radarr logs")]
@@ -104,10 +112,10 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
-      RadarrListCommand::Downloads => {
+      RadarrListCommand::Downloads { count } => {
        let resp = self
          .network
-          .handle_network_event(RadarrEvent::GetDownloads.into())
+          .handle_network_event(RadarrEvent::GetDownloads(count).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
@@ -118,6 +126,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      RadarrListCommand::History { events: items } => {
        let resp = self
          .network
          .handle_network_event(RadarrEvent::GetHistory(items).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      RadarrListCommand::Indexers => {
        let resp = self
          .network
@@ -135,9 +150,9 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
          .await?;
        if output_in_log_format {
-          let log_lines = self.app.lock().await.data.radarr_data.logs.items.clone();
+          let log_lines = &self.app.lock().await.data.radarr_data.logs.items;
-          serde_json::to_string_pretty(&log_lines)?
+          serde_json::to_string_pretty(log_lines)?
        } else {
          serde_json::to_string_pretty(&logs)?
        }
@@ -1,12 +1,12 @@
 #[cfg(test)]
 mod tests {
  use clap::error::ErrorKind;
  use clap::CommandFactory;
  use clap::error::ErrorKind;
  use crate::cli::radarr::list_command_handler::RadarrListCommand;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::Command;
  use crate::Cli;
  use crate::cli::Command;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::radarr::list_command_handler::RadarrListCommand;
  use pretty_assertions::assert_eq;
  #[test]
@@ -29,7 +29,6 @@ mod tests {
      #[values(
        "blocklist",
        "collections",
        "downloads",
        "disk-space",
        "indexers",
        "movies",
@@ -44,7 +43,7 @@ mod tests {
    ) {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "list", subcommand]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
@@ -52,19 +51,28 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "list", "movie-credits"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
      );
    }
    #[test]
    fn test_list_downloads_count_flag_requires_arguments() {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "list", "downloads", "--count"]);
      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
    #[test]
    fn test_list_logs_events_flag_requires_arguments() {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "list", "logs", "--events"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -80,11 +88,50 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::List(credits_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::List(credits_command))) = result.unwrap().command
      else {
        panic!("Unexpected command type");
      };
      assert_eq!(credits_command, expected_args);
    }
    #[test]
    fn test_list_downloads_default_values() {
      let expected_args = RadarrListCommand::Downloads { count: 500 };
      let result = Cli::try_parse_from(["managarr", "radarr", "list", "downloads"]);
      assert_ok!(&result);
      let Some(Command::Radarr(RadarrCommand::List(refresh_command))) = result.unwrap().command
      else {
        panic!("Unexpected command type");
      };
      assert_eq!(refresh_command, expected_args);
    }
    #[test]
    fn test_list_history_events_flag_requires_arguments() {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "list", "history", "--events"]);
      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
    #[test]
    fn test_list_history_default_values() {
      let expected_args = RadarrListCommand::History { events: 500 };
      let result = Cli::try_parse_from(["managarr", "radarr", "list", "history"]);
      assert_ok!(&result);
      let Some(Command::Radarr(RadarrCommand::List(history_command))) = result.unwrap().command
      else {
        panic!("Unexpected command type");
      };
      assert_eq!(history_command, expected_args);
    }
    #[test]
@@ -95,13 +142,15 @@ mod tests {
      };
      let result = Cli::try_parse_from(["managarr", "radarr", "list", "logs"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::List(refresh_command))) = result.unwrap().command {
+      let Some(Command::Radarr(RadarrCommand::List(refresh_command))) = result.unwrap().command
      else {
        panic!("Unexpected command type");
      };
      assert_eq!(refresh_command, expected_args);
    }
  }
  }
  mod handler {
    use std::sync::Arc;
@@ -115,14 +164,13 @@ mod tests {
    use crate::{
      app::App,
      cli::radarr::list_command_handler::{RadarrListCommand, RadarrListCommandHandler},
-      models::{radarr_models::RadarrSerdeable, Serdeable},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    #[rstest]
    #[case(RadarrListCommand::Blocklist, RadarrEvent::GetBlocklist)]
    #[case(RadarrListCommand::Collections, RadarrEvent::GetCollections)]
    #[case(RadarrListCommand::Downloads, RadarrEvent::GetDownloads)]
    #[case(RadarrListCommand::DiskSpace, RadarrEvent::GetDiskSpace)]
    #[case(RadarrListCommand::Indexers, RadarrEvent::GetIndexers)]
    #[case(RadarrListCommand::Movies, RadarrEvent::GetMovies)]
@@ -147,13 +195,13 @@ 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 result = RadarrListCommandHandler::with(&app_arc, list_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -171,7 +219,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 list_movie_credits_command = RadarrListCommand::MovieCredits { movie_id: 1 };
      let result =
@@ -179,7 +227,59 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      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>(
          RadarrEvent::GetDownloads(expected_count).into(),
        ))
        .times(1)
        .returning(|_| {
          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
            json!({"testResponse": "response"}),
          )))
        });
      let app_arc = Arc::new(Mutex::new(App::test_default()));
      let list_downloads_command = RadarrListCommand::Downloads { count: 1000 };
      let result =
        RadarrListCommandHandler::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>(
          RadarrEvent::GetHistory(expected_events).into(),
        ))
        .times(1)
        .returning(|_| {
          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
            json!({"testResponse": "response"}),
          )))
        });
      let app_arc = Arc::new(Mutex::new(App::test_default()));
      let list_history_command = RadarrListCommand::History { events: 1000 };
      let result =
        RadarrListCommandHandler::with(&app_arc, list_history_command, &mut mock_network)
          .handle()
          .await;
      assert_ok!(&result);
    }
    #[tokio::test]
@@ -197,7 +297,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 list_logs_command = RadarrListCommand::Logs {
        events: 1000,
        output_in_log_format: false,
@@ -207,7 +307,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -13,8 +13,8 @@ use crate::app::App;
 use crate::cli::CliCommandHandler;
 use crate::models::radarr_models::{RadarrReleaseDownloadBody, RadarrTaskName};
 use crate::network::radarr_network::RadarrEvent;
 use crate::network::NetworkTrait;
 use crate::network::radarr_network::RadarrEvent;
 use anyhow::Result;
 use super::Command;
@@ -64,6 +64,15 @@ pub enum RadarrCommand {
  Refresh(RadarrRefreshCommand),
  #[command(about = "Clear the blocklist")]
  ClearBlocklist,
  #[command(about = "Mark the Radarr history item with the given ID as 'failed'")]
  MarkHistoryItemAsFailed {
    #[arg(
      long,
      help = "The Radarr ID of the history item you wish to mark as 'failed'",
      required = true
    )]
    history_item_id: i64,
  },
  #[command(about = "Manually download the given release for the specified movie ID")]
  DownloadRelease {
    #[arg(long, help = "The GUID of the release to download", required = true)]
@@ -118,6 +127,17 @@ pub enum RadarrCommand {
  },
  #[command(about = "Test all Radarr indexers")]
  TestAllIndexers,
  #[command(
    about = "Toggle monitoring for the specified movie corresponding to the given movie ID"
  )]
  ToggleMovieMonitoring {
    #[arg(
      long,
      help = "The Radarr ID of the movie to toggle monitoring on",
      required = true
    )]
    movie_id: i64,
  },
  #[command(about = "Trigger an automatic search for the movie with the specified ID")]
  TriggerAutomaticSearch {
    #[arg(
@@ -197,6 +217,15 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrCommand> for RadarrCliHandler<'a, '
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      RadarrCommand::MarkHistoryItemAsFailed { history_item_id } => {
        let _ = self
          .network
          .handle_network_event(RadarrEvent::MarkHistoryItemAsFailed(history_item_id).into())
          .await?;
        serde_json::to_string_pretty(
          &serde_json::json!({"message": "Radarr history item marked as 'failed'"}),
        )?
      }
      RadarrCommand::DownloadRelease {
        guid,
        indexer_id,
@@ -250,6 +279,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrCommand> for RadarrCliHandler<'a, '
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      RadarrCommand::ToggleMovieMonitoring { movie_id } => {
        let resp = self
          .network
          .handle_network_event(RadarrEvent::ToggleMovieMonitoring(movie_id).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      RadarrCommand::TriggerAutomaticSearch { movie_id } => {
        let resp = self
          .network
@@ -1,11 +1,11 @@
 #[cfg(test)]
 mod tests {
  use clap::error::ErrorKind;
  use clap::CommandFactory;
  use clap::error::ErrorKind;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::Command;
  use crate::Cli;
  use crate::cli::Command;
  use crate::cli::radarr::RadarrCommand;
  use pretty_assertions::assert_eq;
  #[test]
@@ -28,7 +28,32 @@ mod tests {
    ) {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", subcommand]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_mark_history_item_as_failed_requires_history_item_id() {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "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",
        "radarr",
        "mark-history-item-as-failed",
        "--history-item-id",
        "1",
      ]);
      assert_ok!(&result);
    }
    #[test]
@@ -43,7 +68,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -62,7 +87,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -81,7 +106,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -102,14 +127,14 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_manual_search_requires_movie_id() {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "manual-search"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -126,14 +151,14 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_search_new_movie_requires_query() {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "search-new-movie"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -150,14 +175,14 @@ mod tests {
        "halo",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_start_task_requires_task_name() {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "start-task"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -174,7 +199,7 @@ mod tests {
        "test",
      ]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
    }
@@ -188,14 +213,14 @@ mod tests {
        "application-check-update",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_test_indexer_requires_indexer_id() {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "test-indexer"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -212,7 +237,32 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_toggle_movie_monitoring_requires_movie_id() {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "toggle-movie-monitoring"]);
      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
      );
    }
    #[test]
    fn test_toggle_movie_monitoring_requirements_satisfied() {
      let result = Cli::command().try_get_matches_from([
        "managarr",
        "radarr",
        "toggle-movie-monitoring",
        "--movie-id",
        "1",
      ]);
      assert_ok!(&result);
    }
    #[test]
@@ -220,7 +270,7 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "trigger-automatic-search"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -237,7 +287,7 @@ mod tests {
        "1",
      ]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
@@ -251,22 +301,22 @@ mod tests {
    use crate::{
      app::App,
      cli::{
        radarr::{
          add_command_handler::RadarrAddCommand, delete_command_handler::RadarrDeleteCommand,
          edit_command_handler::RadarrEditCommand, get_command_handler::RadarrGetCommand,
          list_command_handler::RadarrListCommand, refresh_command_handler::RadarrRefreshCommand,
          RadarrCliHandler, RadarrCommand,
        },
        CliCommandHandler,
        radarr::{
          RadarrCliHandler, RadarrCommand, add_command_handler::RadarrAddCommand,
          delete_command_handler::RadarrDeleteCommand, edit_command_handler::RadarrEditCommand,
          get_command_handler::RadarrGetCommand, list_command_handler::RadarrListCommand,
          refresh_command_handler::RadarrRefreshCommand,
        },
      },
      models::{
        Serdeable,
        radarr_models::{
          BlocklistItem, BlocklistResponse, IndexerSettings, RadarrReleaseDownloadBody,
          RadarrSerdeable, RadarrTaskName,
        },
        Serdeable,
      },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    #[tokio::test]
@@ -292,14 +342,44 @@ 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 clear_blocklist_command = RadarrCommand::ClearBlocklist;
      let result = RadarrCliHandler::with(&app_arc, clear_blocklist_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
    async fn test_mark_history_item_as_failed_command() {
      let expected_history_item_id = 1;
      let mut mock_network = MockNetworkTrait::new();
      mock_network
        .expect_handle_network_event()
        .with(eq::<NetworkEvent>(
          RadarrEvent::MarkHistoryItemAsFailed(expected_history_item_id).into(),
        ))
        .times(1)
        .returning(|_| {
          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
            json!({"testResponse": "response"}),
          )))
        });
      let app_arc = Arc::new(Mutex::new(App::test_default()));
      let mark_history_item_as_failed_command =
        RadarrCommand::MarkHistoryItemAsFailed { history_item_id: 1 };
      let result = RadarrCliHandler::with(
        &app_arc,
        mark_history_item_as_failed_command,
        &mut mock_network,
      )
      .handle()
      .await;
      assert_ok!(&result);
    }
    #[tokio::test]
@@ -321,7 +401,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 download_release_command = RadarrCommand::DownloadRelease {
        guid: "guid".to_owned(),
        indexer_id: 1,
@@ -332,7 +412,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -350,14 +430,14 @@ 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 manual_search_command = RadarrCommand::ManualSearch { movie_id: 1 };
      let result = RadarrCliHandler::with(&app_arc, manual_search_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -375,7 +455,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 search_new_movie_command = RadarrCommand::SearchNewMovie {
        query: "halo".to_owned(),
      };
@@ -384,7 +464,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -402,7 +482,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 start_task_command = RadarrCommand::StartTask {
        task_name: RadarrTaskName::ApplicationCheckUpdate,
      };
@@ -411,7 +491,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -429,14 +509,14 @@ 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 test_indexer_command = RadarrCommand::TestIndexer { indexer_id: 1 };
      let result = RadarrCliHandler::with(&app_arc, test_indexer_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -451,14 +531,40 @@ 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 test_all_indexers_command = RadarrCommand::TestAllIndexers;
      let result = RadarrCliHandler::with(&app_arc, test_all_indexers_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
    async fn test_toggle_movie_monitoring_command() {
      let expected_movie_id = 1;
      let mut mock_network = MockNetworkTrait::new();
      mock_network
        .expect_handle_network_event()
        .with(eq::<NetworkEvent>(
          RadarrEvent::ToggleMovieMonitoring(expected_movie_id).into(),
        ))
        .times(1)
        .returning(|_| {
          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
            json!({"testResponse": "response"}),
          )))
        });
      let app_arc = Arc::new(Mutex::new(App::test_default()));
      let toggle_movie_monitoring_command = RadarrCommand::ToggleMovieMonitoring { movie_id: 1 };
      let result =
        RadarrCliHandler::with(&app_arc, toggle_movie_monitoring_command, &mut mock_network)
          .handle()
          .await;
      assert_ok!(&result);
    }
    #[tokio::test]
@@ -476,7 +582,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 trigger_automatic_search_command = RadarrCommand::TriggerAutomaticSearch { movie_id: 1 };
      let result = RadarrCliHandler::with(
@@ -487,7 +593,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -505,7 +611,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 = RadarrCommand::Add(RadarrAddCommand::Tag {
        name: expected_tag_name,
      });
@@ -514,7 +620,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -532,7 +638,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 =
        RadarrCommand::Delete(RadarrDeleteCommand::BlocklistItem {
          blocklist_item_id: 1,
@@ -543,7 +649,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -592,7 +698,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 =
        RadarrCommand::Edit(RadarrEditCommand::AllIndexerSettings {
          allow_hardcoded_subs: true,
@@ -615,7 +721,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -632,7 +738,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 get_all_indexer_settings_command =
        RadarrCommand::Get(RadarrGetCommand::AllIndexerSettings);
@@ -644,7 +750,7 @@ mod tests {
      .handle()
      .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -662,7 +768,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 list_movie_credits_command =
        RadarrCommand::List(RadarrListCommand::MovieCredits { movie_id: 1 });
@@ -670,7 +776,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -688,7 +794,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 refresh_movie_command =
        RadarrCommand::Refresh(RadarrRefreshCommand::Movie { movie_id: 1 });
@@ -696,7 +802,7 @@ mod tests {
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -7,7 +7,7 @@ use tokio::sync::Mutex;
 use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 use super::RadarrCommand;
@@ -1,12 +1,12 @@
 #[cfg(test)]
 mod tests {
  use clap::error::ErrorKind;
  use clap::CommandFactory;
  use clap::error::ErrorKind;
  use crate::cli::radarr::refresh_command_handler::RadarrRefreshCommand;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::Command;
  use crate::Cli;
  use crate::cli::Command;
  use crate::cli::radarr::RadarrCommand;
  use crate::cli::radarr::refresh_command_handler::RadarrRefreshCommand;
  use pretty_assertions::assert_eq;
  #[test]
@@ -31,14 +31,14 @@ mod tests {
      let result =
        Cli::command().try_get_matches_from(["managarr", "radarr", "refresh", subcommand]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[test]
    fn test_refresh_movie_requires_movie_id() {
      let result = Cli::command().try_get_matches_from(["managarr", "radarr", "refresh", "movie"]);
-      assert!(result.is_err());
+      assert_err!(&result);
      assert_eq!(
        result.unwrap_err().kind(),
        ErrorKind::MissingRequiredArgument
@@ -51,15 +51,15 @@ mod tests {
      let result =
        Cli::try_parse_from(["managarr", "radarr", "refresh", "movie", "--movie-id", "1"]);
-      assert!(result.is_ok());
+      assert_ok!(&result);
-      if let Some(Command::Radarr(RadarrCommand::Refresh(refresh_command))) =
+      let Some(Command::Radarr(RadarrCommand::Refresh(refresh_command))) = result.unwrap().command
-        result.unwrap().command
+      else {
-      {
+        panic!("Unexpected command type");
      };
      assert_eq!(refresh_command, expected_args);
    }
  }
  }
  mod handler {
    use rstest::rstest;
@@ -73,8 +73,8 @@ mod tests {
    use crate::{
      app::App,
      cli::radarr::refresh_command_handler::{RadarrRefreshCommand, RadarrRefreshCommandHandler},
-      models::{radarr_models::RadarrSerdeable, Serdeable},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
    };
    #[rstest]
@@ -96,13 +96,13 @@ 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 result = RadarrRefreshCommandHandler::with(&app_arc, refresh_command, &mut mock_network)
        .handle()
        .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
    #[tokio::test]
@@ -120,7 +120,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 refresh_movie_command = RadarrRefreshCommand::Movie { movie_id: 1 };
      let result =
@@ -128,7 +128,7 @@ mod tests {
          .handle()
          .await;
-      assert!(result.is_ok());
+      assert_ok!(&result);
    }
  }
 }
@@ -0,0 +1,224 @@
 use std::sync::Arc;
 use anyhow::Result;
 use clap::{ArgAction, Subcommand};
 use tokio::sync::Mutex;
 use super::ReadarrCommand;
 use crate::{
  app::App,
  cli::{CliCommandHandler, Command},
  models::readarr_models::{
    AddAuthorBody, AddAuthorOptions, AddReadarrRootFolderBody, MonitorType, NewItemMonitorType,
  },
  network::{NetworkTrait, readarr_network::ReadarrEvent},
 };
 #[cfg(test)]
 #[path = "add_command_handler_tests.rs"]
 mod add_command_handler_tests;
 #[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
 pub enum ReadarrAddCommand {
  #[command(about = "Add a new author to your Readarr library")]
  Author {
    #[arg(
      long,
      help = "The Goodreads foreign author ID of the author you wish to add to your library",
      required = true
    )]
    foreign_author_id: String,
    #[arg(long, help = "The name of the author", required = true)]
    author_name: String,
    #[arg(
      long,
      help = "The root folder path where all author data and metadata should live",
      required = true
    )]
    root_folder_path: String,
    #[arg(
      long,
      help = "The ID of the quality profile to use for this author",
      required = true
    )]
    quality_profile_id: i64,
    #[arg(
      long,
      help = "The ID of the metadata profile to use for this author",
      required = true
    )]
    metadata_profile_id: i64,
    #[arg(long, help = "Disable monitoring for this author")]
    disable_monitoring: bool,
    #[arg(
      long,
      help = "Tag IDs to tag the author with",
      value_parser,
      action = ArgAction::Append
    )]
    tag: Vec<i64>,
    #[arg(
      long,
      help = "What Readarr should monitor for this author",
      value_enum,
      default_value_t = MonitorType::default()
    )]
    monitor: MonitorType,
    #[arg(
      long,
      help = "How Readarr should monitor new items for this author",
      value_enum,
      default_value_t = NewItemMonitorType::default()
    )]
    monitor_new_items: NewItemMonitorType,
    #[arg(
      long,
      help = "Tell Readarr to not start a search for missing books once the author is added to your library"
    )]
    no_search_for_missing_books: 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 authors in this root folder",
      required = true
    )]
    quality_profile_id: i64,
    #[arg(
      long,
      help = "The ID of the default metadata profile for authors in this root folder",
      required = true
    )]
    metadata_profile_id: i64,
    #[arg(
      long,
      help = "The default monitor option for authors in this root folder",
      value_enum,
      default_value_t = MonitorType::default()
    )]
    monitor: MonitorType,
    #[arg(
      long,
      help = "The default monitor new items option for authors in this root folder",
      value_enum,
      default_value_t = NewItemMonitorType::default()
    )]
    monitor_new_items: NewItemMonitorType,
    #[arg(
      long,
      help = "Default tag IDs for authors 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<ReadarrAddCommand> for Command {
  fn from(value: ReadarrAddCommand) -> Self {
    Command::Readarr(ReadarrCommand::Add(value))
  }
 }
 pub(super) struct ReadarrAddCommandHandler<'a, 'b> {
  _app: &'a Arc<Mutex<App<'b>>>,
  command: ReadarrAddCommand,
  network: &'a mut dyn NetworkTrait,
 }
 impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrAddCommand> for ReadarrAddCommandHandler<'a, 'b> {
  fn with(
    app: &'a Arc<Mutex<App<'b>>>,
    command: ReadarrAddCommand,
    network: &'a mut dyn NetworkTrait,
  ) -> Self {
    ReadarrAddCommandHandler {
      _app: app,
      command,
      network,
    }
  }
  async fn handle(self) -> Result<String> {
    let result = match self.command {
      ReadarrAddCommand::Author {
        foreign_author_id,
        author_name,
        root_folder_path,
        quality_profile_id,
        metadata_profile_id,
        disable_monitoring,
        tag: tags,
        monitor,
        monitor_new_items,
        no_search_for_missing_books,
      } => {
        let body = AddAuthorBody {
          foreign_author_id,
          author_name,
          monitored: !disable_monitoring,
          root_folder_path,
          quality_profile_id,
          metadata_profile_id,
          tags,
          images: Vec::new(),
          tag_input_string: None,
          add_options: AddAuthorOptions {
            monitor,
            monitor_new_items,
            search_for_missing_books: !no_search_for_missing_books,
          },
        };
        let resp = self
          .network
          .handle_network_event(ReadarrEvent::AddAuthor(body).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      ReadarrAddCommand::RootFolder {
        name,
        root_folder_path,
        quality_profile_id,
        metadata_profile_id,
        monitor,
        monitor_new_items,
        tag: tags,
      } => {
        let add_root_folder_body = AddReadarrRootFolderBody {
          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(ReadarrEvent::AddRootFolder(add_root_folder_body).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
      ReadarrAddCommand::Tag { name } => {
        let resp = self
          .network
          .handle_network_event(ReadarrEvent::AddTag(name).into())
          .await?;
        serde_json::to_string_pretty(&resp)?
      }
    };
    Ok(result)
  }
 }