test: Wrote snapshot tests for all Sonarr UI

# Conflicts:
#	Cargo.lock
#	src/cli/mod.rs
#	src/cli/radarr/add_command_handler.rs
#	src/cli/radarr/get_command_handler.rs
#	src/cli/radarr/list_command_handler.rs

.actrc

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

.cargo-husky/hooks/pre-commit

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

.cargo-husky/hooks/pre-push

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

.cz.toml

@@ -5,3 +5,6 @@ version_scheme = "semver"
 version_provider = "cargo"
 update_changelog_on_bump = true
 major_version_zero = true
+
+[tool.commitizen.hooks]
+pre-commit = "git add Cargo.toml Cargo.lock"

.github/workflows/check.yml

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

.github/workflows/release-major.yml

@@ -1,38 +0,0 @@
-# Adapted from https://github.com/joshka/github-workflows/blob/main/.github/workflows/rust-release-plz.yml
-# Thanks to joshka for permission to use this template!
-
-name: Create major release
-
-permissions:
-  pull-requests: write
-  contents: write
-
-on:
-  workflow_dispatch:
-
-jobs:
-  release-plz:
-    # see https://release-plz.ieni.dev/docs/github
-    # for more information
-    name: Release-plz
-    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
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Run release-plz
-        uses: MarcoIeni/release-plz-action@v0.5
-        with:
-          command: release --bump-major
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/release-minor.yml

@@ -1,38 +0,0 @@
-# Adapted from https://github.com/joshka/github-workflows/blob/main/.github/workflows/rust-release-plz.yml
-# Thanks to joshka for permission to use this template!
-
-name: Create minor release
-
-permissions:
-  pull-requests: write
-  contents: write
-
-on:
-  workflow_dispatch:
-
-jobs:
-  release-plz:
-    # see https://release-plz.ieni.dev/docs/github
-    # for more information
-    name: Release-plz
-    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
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Run release-plz
-        uses: MarcoIeni/release-plz-action@v0.5
-        with:
-          command: release --bump-minor
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/release-patch.yml

@@ -1,38 +0,0 @@
-# Adapted from https://github.com/joshka/github-workflows/blob/main/.github/workflows/rust-release-plz.yml
-# Thanks to joshka for permission to use this template!
-
-name: Create patch release
-
-permissions:
-  pull-requests: write
-  contents: write
-
-on:
-  workflow_dispatch:
-
-jobs:
-  release-plz:
-    # see https://release-plz.ieni.dev/docs/github
-    # for more information
-    name: Release-plz
-    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
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Run release-plz
-        uses: MarcoIeni/release-plz-action@v0.5
-        with:
-          command: release --bump-patch
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/release.yml

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

.github/workflows/test.yml

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

.gitignore

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

.helix/config.toml

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

CHANGELOG.md

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

CONTRIBUTING.md

@@ -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.
 
@@ -46,12 +63,33 @@ cz commit
 ## Setup workspace
 
 1. Clone this repo
-2. Run `cargo test` to setup hooks
+2. Run `cargo test` to set up hooks
 3. Make changes
-4. Run the application using `make run` or `cargo run`
+4. Run the application using `just run` or `just run`
+   - Install `just` (`cargo install just`) if you haven't already to use the [justfile](./justfile) in this project.
 5. Commit changes. This will trigger pre-commit hooks that will run format, test and lint. If there are errors or warnings from Clippy, please fix them.
 6. Push your code to a new branch named after the feature/bug/etc. you're adding. This will trigger pre-push hooks that will run lint and test.
 7. Create a PR
 
+### CI/CD Testing with Act
+If you also are planning on testing out your changes before pushing them with [Act](https://github.com/nektos/act), you will need to set up `act`,
+`docker`, and configure your local system to run different architectures:
+
+1. Install `docker` by following the instructions on the [official Docker installation page](https://docs.docker.com/get-docker/).
+2. Install `act` by following the instructions on the [official Act installation page](https://nektosact.com/installation/index.html).
+3. Install `binfmt` on your system once so that `act` can run the correct architecture for the CI/CD workflows. 
+   You can do this by running:
+   ```shell
+   sudo docker run --rm --privileged tonistiigi/binfmt --install all
+   ```
+   
+Then, you can run workflows locally without having to commit and see if the GitHub action passes or fails. 
+
+**For example**: To test the [release.yml](.github/workflows/release.yml) workflow locally, you can run:
+
+```shell
+act -W .github/workflows/release.yml --input_type bump=minor
+```
+
 ## Questions? Reach out to me!
 If you encounter any questions while developing Managarr, please don't hesitate to reach out to me at alex.j.tusa@gmail.com. I'm happy to help contributors, new and experienced in any way I can!

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "managarr"
-version = "0.2.1"
+version = "0.6.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,50 +8,76 @@ documentation = "https://github.com/Dark-Alex-17/managarr"
 repository = "https://github.com/Dark-Alex-17/managarr"
 homepage = "https://github.com/Dark-Alex-17/managarr"
 readme = "README.md"
-edition = "2021"
+edition = "2024"
 license = "MIT"
-rust-version = "1.82.0"
+rust-version = "1.89.0"
 exclude = [".github", "CONTRIBUTING.md", "*.log", "tags"]
 
+[workspace]
+members = [
+  "proc_macros/enum_display_style_derive",
+  "proc_macros/validate_theme_derive",
+]
+
 [dependencies]
 anyhow = "1.0.68"
-backtrace = "0.3.67"
+backtrace = "0.3.74"
 bimap = { version = "0.6.3", features = ["serde"] }
 chrono = { version = "0.4.38", features = ["serde"] }
 confy = { version = "0.6.0", default-features = false, features = [
   "yaml_conf",
 ] }
-crossterm = "0.27.0"
+crossterm = "0.28.1"
 derivative = "2.2.0"
-human-panic = "1.1.3"
+human-panic = "2.0.2"
 indoc = "2.0.0"
 log = "0.4.17"
 log4rs = { version = "1.2.0", features = ["file_appender"] }
 regex = "1.11.1"
-reqwest = { version = "0.11.14", features = ["json"] }
+reqwest = { version = "0.12.9", features = ["json"] }
 serde_yaml = "0.9.16"
 serde_json = "1.0.91"
 serde = { version = "1.0.214", features = ["derive"] }
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-tokio = { version = "1.36.0", features = ["full"] }
+tokio = { version = "1.44.2", features = ["full"] }
 tokio-util = "0.7.8"
-ratatui = { version = "0.28.0", features = ["all-widgets"] }
+ratatui = { version = "0.29.0", features = [
+  "all-widgets",
+  "unstable-widget-ref",
+] }
 urlencoding = "2.1.2"
-clap = { version = "4.5.20", features = ["derive", "cargo", "env"] }
+clap = { version = "4.5.20", features = [
+  "derive",
+  "cargo",
+  "env",
+  "wrap_help",
+] }
 clap_complete = "4.5.33"
-itertools = "0.13.0"
+itertools = "0.14.0"
 ctrlc = "3.4.5"
-colored = "2.1.0"
+colored = "3.0.0"
 async-trait = "0.1.83"
 dirs-next = "2.0.0"
+managarr-tree-widget = "0.24.0"
+indicatif = "0.17.9"
+derive_setters = "0.1.6"
+deunicode = "1.6.0"
+openssl = { version = "0.10.70", 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"
 mockall = "0.13.0"
 mockito = "1.0.0"
 pretty_assertions = "1.3.0"
-rstest = "0.18.2"
+proptest = "1.6.0"
+rstest = "0.25.0"
+serial_test = "3.2.0"
+assertables = "9.8.2"
+insta = "1.41.1"
 
 [dev-dependencies.cargo-husky]
 version = "1"

Dockerfile

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

LICENSE

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

Makefile

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

README.md

@@ -1,22 +1,26 @@
 # managarr - A TUI and CLI to manage your Servarrs
 
-![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)
+![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)
 ![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/library.png)
+![library](screenshots/sonarr/sonarr_library.png)
 
 ## What Servarrs are supported?
 
 - [x] ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
-- [ ] ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
+- [x] ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
 - [ ] ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
 - [ ] ![lidarr_logo](logos/lidarr.png) [Lidarr](https://wiki.servarr.com/en/lidarr)
 - [ ] ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
@@ -24,7 +28,7 @@ Managarr is a TUI and CLI to help you manage your HTPC (Home Theater PC). Built
 - [ ] ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
 - [ ] ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)
 
-## Try Before You Buy
+## Try Out the Demo
 To try out Managarr before linking it to your HTPC, you can use the purpose built [managarr-demo](https://github.com/Dark-Alex-17/managarr-demo) repository.
 Simply run the following command to start a demo:
 
@@ -32,7 +36,10 @@ Simply run the following command to start a demo:
 curl https://raw.githubusercontent.com/Dark-Alex-17/managarr-demo/main/managarr-demo.sh > /tmp/managarr-demo.sh && bash /tmp/managarr-demo.sh
 ```
 
+Alternatively, you can try out the demo container without downloading anything by visiting the [Managarr Demo site](https://managarr-demo.alexjclarke.com).
+
 ## Installation
+
 ### Cargo
 If you have Cargo installed, then you can install Managarr from Crates.io:
 
@@ -46,34 +53,134 @@ cargo install --locked managarr
 ### Docker
 Run Managarr as a docker container by mounting your `config.yml` file to `/root/.config/managarr/config.yml`. For example:
 ```shell
-docker run --rm -it -v ~/.config/managarr:/root/.config/managarr darkalex17/managarr
+docker run --rm -it -v /home/aclarke/.config/managarr/config.yml:/root/.config/managarr/config.yml darkalex17/managarr:latest
 ```
 
 You can also clone this repo and run `make docker` to build a docker image locally and run it using the above command.
 
+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.
+
+**Note:** If you run into errors using relative file paths when mounting the volume with the configuration file, try using an absolute path.
+
+### Homebrew (Mac and Linux)
+To install Managarr from Homebrew, install the Managarr tap. Then you'll be able to install Managarr:
+
+```shell
+brew tap Dark-Alex-17/managarr
+brew install managarr
+
+# If you need to be more specific, use the following:
+brew install Dark-Alex-17/managarr/managarr
+```
+
+To upgrade to a newer version of Managarr:
+```shell
+brew upgrade managarr
+```
+
+### Nix (Externally Maintained)
+To install Managarr on NixOS, you can use the following command:
+
+```shell
+nix-env --install managarr
+
+# Alternatively, for non-NixOS users, you can spawn a temporary shell with Managarr available like so:
+nix-shell -p managarr
+```
+
+### Chocolatey (Windows)
+The Managarr Chocolatey package is located [here](https://community.chocolatey.org/packages/managarr). Please note that validation
+of Chocolatey packages take quite some time, and thus the package may not be available immediately after a new release.
+
+```powershell
+choco install managarr
+
+# Some newer releases may require a version number, so you can specify it like so:
+choco install managarr --version=0.5.0
+```
+
+To upgrade to the latest and greatest version of Managarr:
+```powershell
+choco upgrade managarr
+
+# To upgrade to a specific version:
+choco upgrade managarr --version=0.5.0
+```
+
+### Manual
+Binaries are available on the [releases](https://github.com/Dark-Alex-17/managarr/releases) page for the following platforms:
+
+| Platform       | Architecture(s)            |
+|----------------|----------------------------|
+| macOS          | x86_64, arm64              |
+| Linux GNU/MUSL | x86_64,armv6,armv7,aarch64 |
+| Windows        | x86_64,aarch64             |
+
+#### Windows Instructions
+To use a binary from the releases page on Windows, do the following:
+
+1. Download the latest [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+2. Use 7-Zip or TarTool to unpack the Tar file.
+3. Run the executable `managarr.exe`!
+
+#### Linux/MacOS Instructions
+To use a binary from the releases page on Linux/MacOS, do the following:
+
+1. Download the latest [binary](https://github.com/Dark-Alex-17/managarr/releases) for your OS.
+2. `cd` to the directory where you downloaded the binary.
+3. Extract the binary with `tar -C /usr/local/bin -xzf managarr-<arch>.tar.gz` (Note: This may require `sudo`)
+4. Now you can run `managarr`!
+
 ## Features
+Key:
+
+| Symbol | Status    |
+|--------|-----------|
+| ✅      | Supported |
+| ❌      | Missing   |
+| 🕒     | Planned   |
+| 🚫     | Won't Add |
 
 ### Radarr
 
-- [x] View your library, downloads, collections, and blocklist
-- [x] View details of a specific movie including description, history, downloaded file info, or the credits
-- [x] View details of any collection and the movies in them
-- [x] View your host and security configs from the CLI to programmatically fetch the API token, among other settings
-- [x] Search your library or collections
-- [x] Add movies to your library
-- [x] Delete movies, downloads, and indexers
-- [x] Trigger automatic searches for movies
-- [x] Trigger refresh and disk scan for movies, downloads, and collections
-- [x] Manually search for movies
-- [x] Edit your movies, collections, and indexers
-- [x] Manage your tags
-- [x] Manage your root folders
-- [x] Manage your blocklist
-- [x] View and browse logs, tasks, events queues, and updates
-- [x] Manually trigger scheduled tasks
+| TUI | CLI | Feature                                                                                                        |
+|-----|-----|----------------------------------------------------------------------------------------------------------------|
+| ✅   | ✅   | View your library, downloads, collections, and blocklist                                                       |
+| ✅   | ✅   | View details of a specific movie including description, history, downloaded file info, or the credits          |
+| ✅   | ✅   | View details of any collection and the movies in them                                                          |
+| 🚫  | ✅   | View your host and security configs from the CLI to programmatically fetch the API token, among other settings |
+| ✅   | ✅   | Search your library or collections                                                                             |
+| ✅   | ✅   | Add movies to your library                                                                                     |
+| ✅   | ✅   | Delete movies, downloads, and indexers                                                                         |
+| ✅   | ✅   | Trigger automatic searches for movies                                                                          |
+| ✅   | ✅   | Trigger refresh and disk scan for movies, downloads, and collections                                           |
+| ✅   | ✅   | Manually search for movies                                                                                     |
+| ✅   | ✅   | Edit your movies, collections, 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                                                                               |
 
 ### Sonarr
-- [ ] Support for Sonarr
+
+| TUI | CLI | Feature                                                                                                            |
+|-----|-----|--------------------------------------------------------------------------------------------------------------------|
+| ✅   | ✅   | View your library, downloads, blocklist, episodes                                                                  |
+| ✅   | ✅   | View details of a specific series, or episode including description, history, downloaded file info, or the credits |
+| 🚫  | ✅   | View your host and security configs from the CLI to programmatically fetch the API token, among other settings     |
+| ✅   | ✅   | Search your library                                                                                                |
+| ✅   | ✅   | Add series to your library                                                                                         |
+| ✅   | ✅   | Delete series, downloads, indexers, root folders, and episode files                                                |
+| ✅   | ✅   | Trigger automatic searches for series, seasons, or episodes                                                        |
+| ✅   | ✅   | Trigger refresh and disk scan for series and downloads                                                             |
+| ✅   | ✅   | Manually search for series, seasons, or episodes                                                                   |
+| ✅   | ✅   | Edit your series and indexers                                                                                      |
+| ✅   | ✅   | Manage your tags                                                                                                   |
+| ✅   | ✅   | Manage your root folders                                                                                           |
+| ✅   | ✅   | Manage your blocklist                                                                                              |
+| ✅   | ✅   | View and browse logs, tasks, events queues, and updates                                                            |
+| ✅   | ✅   | Manually trigger scheduled tasks                                                                                   |
 
 ### Readarr
 
@@ -99,19 +206,32 @@ You can also clone this repo and run `make docker` to build a docker image local
 
 - [ ] Support for Tautulli
 
+### Themes
+Managarr ships with a few themes out of the box. Here's a few examples:
+
+#### Default
+![default](themes/default/manual_episode_search.png)
+#### Dracula
+![dracula](themes/dracula/manual_episode_search.png)
+#### Watermelon Dark
+![watermelon-dark](themes/watermelon-dark/manual_episode_search.png)
+
+You can also create your own custom themes as well. To learn more about what themes are built-in to Managarr and how
+to create your own custom themes, check out the [Themes README](themes/README.md).
+
 ### The Managarr CLI
 Managarr can be used in one of two ways: As a TUI, or as a CLI for managing your Servarrs. 
 
 All management features available in the TUI are also available in the CLI. However, the CLI is
 equipped with additional features to allow for more advanced usage and automation.
 
-The CLI can be helpful for automating tasks or for use in scripts. For example, you can use the CLI to trigger a search for a movie, or to add a movie to your library.
+The CLI can be helpful for automating tasks or for use in scripts. For example, you can use the CLI to trigger a search for a movie, or to add a movie to your Radarr library.
 
 To see all available commands, simply run `managarr --help`:
 
 ```shell
 $ managarr --help
-managarr 0.2.1
+managarr 0.5.1
 Alex Clarke <alex.j.tusa@gmail.com>
 
 A TUI and CLI to manage your Servarrs
@@ -120,43 +240,55 @@ Usage: managarr [OPTIONS] [COMMAND]
 
 Commands:
   radarr       Commands for manging your Radarr instance
+  sonarr       Commands for manging your Sonarr instance
   completions  Generate shell completions for the Managarr CLI
+  tail-logs    Tail Managarr logs
   help         Print this message or the help of the given subcommand(s)
 
 Options:
-      --config <CONFIG>               The Managarr configuration file to use
-  -h, --help                          Print help
-  -V, --version                       Print version
+      --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.
+  -h, --help                         Print help
+  -V, --version                      Print version
 ```
 
-All subcommands also have detailed help menus to show you how to use them. For example, to see all available commands for Radarr, you would run:
+All subcommands also have detailed help menus to show you how to use them. For example, to see all available commands for Sonarr, you would run:
 
 ```shell
-$ managarr radarr --help
-Commands for manging your Radarr instance
+$ managarr sonarr --help
+Commands for manging your Sonarr instance
 
-Usage: managarr radarr [OPTIONS] <COMMAND>
+Usage: managarr sonarr [OPTIONS] <COMMAND>
 
 Commands:
-  add                       Commands to add or create new resources within your Radarr instance
-  delete                    Commands to delete resources from your Radarr instance
-  edit                      Commands to edit resources in your Radarr instance
-  get                       Commands to fetch details of the resources in your Radarr instance
-  list                      Commands to list attributes from your Radarr instance
-  refresh                   Commands to refresh the data in your Radarr instance
-  clear-blocklist           Clear the blocklist
-  download-release          Manually download the given release for the specified movie ID
-  manual-search             Trigger a manual search of releases for the movie with the given ID
-  search-new-movie          Search for a new film to add to Radarr
-  start-task                Start the specified Radarr task
-  test-indexer              Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'
-  test-all-indexers         Test all indexers
-  trigger-automatic-search  Trigger an automatic search for the movie with the specified ID
-  help                      Print this message or the help of the given subcommand(s)
+  add                          Commands to add or create new resources within your Sonarr instance
+  delete                       Commands to delete resources from your Sonarr instance
+  edit                         Commands to edit resources in your Sonarr instance
+  get                          Commands to fetch details of the resources in your Sonarr instance
+  download                     Commands to download releases in your Sonarr instance
+  list                         Commands to list attributes from your Sonarr instance
+  refresh                      Commands to refresh the data in your Sonarr instance
+  manual-search                Commands to manually search for releases
+  trigger-automatic-search     Commands to trigger automatic searches for releases of different resources in your Sonarr instance
+  clear-blocklist              Clear the blocklist
+  mark-history-item-as-failed  Mark the Sonarr history item with the given ID as 'failed'
+  search-new-series            Search for a new series to add to Sonarr
+  start-task                   Start the specified Sonarr task
+  test-indexer                 Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'
+  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
+  help                         Print this message or the help of the given subcommand(s)
 
 Options:
-      --config <CONFIG>               The Managarr configuration file to use
-  -h, --help                          Print help
+      --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
 ```
 
 **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:
@@ -170,7 +302,7 @@ $ managarr radarr list movies | jq '.[] | select(.title == "Ad Astra") | .id'
 Managarr assumes reasonable defaults to connect to each service (i.e. Radarr is on localhost:7878),
 but all servers will require you to input the API token.
 
-The configuration file is located somewhere different for each OS
+The configuration file is located somewhere different for each OS.
 
 ### Linux
 ```
@@ -193,66 +325,130 @@ 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
-  port: 7878
-  api_token: someApiToken1234567890
-  ssl_cert_path: /path/to/radarr.crt # Required to enable SSL
+  - host: 192.168.0.78
+    port: 7878
+    api_token: someApiToken1234567890
+    ssl_cert_path: /path/to/radarr.crt # Required to enable SSL
 sonarr:
-  uri: http://htpc.local/sonarr # Example of using the 'uri' key instead of 'host' and 'port'
-  api_token: someApiToken1234567890
+  - uri: http://htpc.local/sonarr # Example of using the 'uri' key instead of 'host' and 'port'
+    api_token: someApiToken1234567890
+    
+  - name: Anime Sonarr # An example of a custom name for a secondary Sonarr instance
+    host: 192.168.0.89
+    port: 8989
+    api_token: someApiToken1234567890
 readarr:
-  host: 192.168.0.87
-  port: 8787
-  api_token: someApiToken1234567890
+  - host: 192.168.0.87 
+    port: 8787
+    api_token_file: /root/.config/readarr_api_token # Example of loading the API token from a file instead of hardcoding it in the configuration file
 lidarr:
-  host: 192.168.0.86
-  port: 8686
-  api_token: someApiToken1234567890
+  - host: 192.168.0.86
+    port: 8686
+    api_token: ${MY_LIDARR_API_TOKEN} # Example of configuring using environment variables
 whisparr:
-  host: 192.168.0.69
-  port: 6969
-  api_token: someApiToken1234567890
-  ssl_cert_path: /path/to/whisparr.crt
+  - host: 192.168.0.69
+    port: 6969
+    api_token: someApiToken1234567890
+    ssl_cert_path: /path/to/whisparr.crt
+    custom_headers: # Example of adding custom headers to all requests to the Servarr instance
+      traefik-auth-bypass-key: someBypassKey1234567890
+      SOME-OTHER-CUSTOM-HEADER: ${MY_CUSTOM_HEADER_VALUE}
 bazarr:
-  host: 192.168.0.67
-  port: 6767
-  api_token: someApiToken1234567890
+  - host: 192.168.0.67
+    port: 6767
+    api_token: someApiToken1234567890
 prowlarr:
-  host: 192.168.0.96
-  port: 9696
-  api_token: someApiToken1234567890
+  - host: 192.168.0.96
+    port: 9696
+    api_token: someApiToken1234567890
 tautulli:
-  host: 192.168.0.81
-  port: 8181
-  api_token: someApiToken1234567890
+  - host: 192.168.0.81
+    port: 8181
+    api_token: someApiToken1234567890
+```
+
+### 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
+    ssl_cert_path: /path/to/radarr.crt
+    
+  - name: International Movies
+    host: 192.168.0.79
+    port: 7878
+    api_token: someApiToken1234567890
+sonarr:
+  - name: Anime
+    weight: 1 # This instance will be the first tab in the TUI
+    uri: http://htpc.local/sonarr
+    api_token: someApiToken1234567890
+
+  - name: TV Shows
+    weight: 2 # This instance will be the second tab in the TUI
+    host: 192.168.0.89
+    port: 8989
+    api_token: someApiToken1234567890
+```
+
+In this configuration, you can see that we have multiple instances of Radarr and Sonarr configured. The `weight` key is 
+used to specify the order in which the tabs will appear in the TUI. The lower the weight, the further to the left the 
+tab will appear. If no weight is specified, then tabs will be ordered in the order they appear in the configuration 
+file.
+
+When no `name` is specified for a Servarr instance, the name will default to the name of the Servarr with a number 
+appended to it. For example, if you have two Radarr instances and neither has a name, they will be named `Radarr 1` and 
+`Radarr 2`, respectively.
+
+In this example configuration, the tabs in the TUI would appear as follows:
+
+`Anime | TV Shows | Radarr 1 | International Movies`
+
+### Specify Which Servarr Instance to Use in the CLI
+If you have multiple instances of the same Servarr running, you can specify which instance you want to use by using the `--servarr-name` flag:
+
+```shell
+managarr --servarr-name "International Movies"
 ```
 
 ## Environment Variables
 Managarr supports using environment variables on startup so you don't have to always specify certain flags:
 
-| Variable                                | Description                      | Equivalent Flag                  |
-| --------------------------------------- | -------------------------------- | -------------------------------- |
-| `MANAGARR_CONFIG_FILE`                  | Set the path to the config file  | `--config`                       |
+| Variable                                | Description                                                                    | Equivalent Flag                  |
+|-----------------------------------------|--------------------------------------------------------------------------------|----------------------------------|
+| `MANAGARR_CONFIG_FILE`                  | Set the path to the config file                                                | `--config`                       |
+| `MANAGARR_DISABLE_SPINNER`              | Disable the CLI spinner (this can be useful when scripting and parsing output) | `--disable-spinner`              |
 
-## Track My Progress for the Beta release (With Sonarr Support!)
-Progress for the beta release can be followed on my [Wekan Board](https://wekan.alexjclarke.com/b/dHoGjBb44MHM9HSv4/managarr)
-with all items tagged `Beta`.
+## Track What I'm Currently Working On
+To see what feature(s) I'm currently working on, check out my [Wekan Board](https://wekan.alexjclarke.com/b/dHoGjBb44MHM9HSv4/managarr).
 
 ## Screenshots
 
-![library](screenshots/library.png)
-![manual_search](screenshots/manual_search.png)
-![logs](screenshots/logs.png)
-![new_movie_search](screenshots/new_movie_search.png)
-![add_new_movie](screenshots/add_new_movie.png)
-![collection_details](screenshots/collection_details.png)
-![indexers](screenshots/indexers.png)
+### Radarr
+![radarr_library](screenshots/radarr/radarr_library.png)
+![manual_search](screenshots/radarr/manual_search.png)
+![new_movie_search](screenshots/radarr/new_movie_search.png)
+![add_new_movie](screenshots/radarr/add_new_movie.png)
+![collection_details](screenshots/radarr/collection_details.png)
+
+### Sonarr
+![sonarr_library](screenshots/sonarr/sonarr_library.png)
+![series_details](screenshots/sonarr/series_details.png)
+![season_details](screenshots/sonarr/season_details.png)
+![manual_episode_search](screenshots/sonarr/manual_episode_search.png)
+
+### General
+![logs](screenshots/radarr/logs.png)
+![indexers](screenshots/radarr/indexers.png)
 
 ## Dependencies
 * [ratatui](https://github.com/tui-rs-revival/ratatui)
@@ -264,7 +460,7 @@ with all items tagged `Beta`.
 
 ## Servarr Requirements
 * [Radarr >= 5.3.6.8612](https://radarr.video/docs/api/)
-* [Sonarr >= v3](https://sonarr.tv/docs/api/)
+* [Sonarr >= v4](https://sonarr.tv/docs/api/)
 * [Readarr v1](https://readarr.com/docs/api/)
 * [Lidarr v1](https://lidarr.audio/docs/api/)
 * [Whisparr >= v3](https://whisparr.com/docs/api/)

codecov.yml

@@ -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"

deployment/chocolatey/chocolateyinstall.ps1.template

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

deployment/chocolatey/managarr.nuspec.template

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

deployment/chocolatey/packager.py

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

deployment/homebrew/managarr.rb.template

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

deployment/homebrew/packager.py

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

justfile

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

proc_macros/enum_display_style_derive/Cargo.toml

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

proc_macros/enum_display_style_derive/src/lib.rs

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

proc_macros/enum_display_style_derive/src/macro_models.rs

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

proc_macros/validate_theme_derive/Cargo.toml

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

proc_macros/validate_theme_derive/src/lib.rs

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

proptest-regressions/handlers/handler_proptest.txt

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

proptest-regressions/handlers/table_handler_tests.txt

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

proptest-regressions/ui/ui_property_tests.txt

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

src/app/app_tests.rs

@@ -1,66 +1,122 @@
 #[cfg(test)]
 mod tests {
   use anyhow::anyhow;
-  use pretty_assertions::assert_eq;
+  use pretty_assertions::{assert_eq, assert_str_eq};
+  use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
+  use serde_json::Value;
+  use serial_test::serial;
   use tokio::sync::mpsc;
 
-  use crate::app::context_clues::{build_context_clue_string, SERVARR_CONTEXT_CLUES};
-  use crate::app::{App, Data, RadarrConfig, DEFAULT_ROUTE};
+  use crate::app::{App, AppConfig, Data, ServarrConfig, interpolate_env_vars};
   use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
-  use crate::models::{HorizontallyScrollableText, Route, TabRoute};
-  use crate::network::radarr_network::RadarrEvent;
+  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
+  use crate::models::{HorizontallyScrollableText, TabRoute};
   use crate::network::NetworkEvent;
+  use crate::network::radarr_network::RadarrEvent;
+  use tokio_util::sync::CancellationToken;
 
   #[test]
-  fn test_app_default() {
-    let app = App::default();
+  fn test_app_new() {
+    let radarr_config_1 = ServarrConfig {
+      name: Some("Radarr Test".to_owned()),
+      ..ServarrConfig::default()
+    };
+    let radarr_config_2 = ServarrConfig {
+      weight: Some(3),
+      ..ServarrConfig::default()
+    };
+    let sonarr_config_1 = ServarrConfig {
+      name: Some("Sonarr Test".to_owned()),
+      weight: Some(1),
+      ..ServarrConfig::default()
+    };
+    let sonarr_config_2 = ServarrConfig::default();
+    let config = AppConfig {
+      theme: None,
+      radarr: Some(vec![radarr_config_1.clone(), radarr_config_2.clone()]),
+      sonarr: Some(vec![sonarr_config_1.clone(), sonarr_config_2.clone()]),
+    };
+    let expected_tab_routes = vec![
+      TabRoute {
+        title: "Sonarr Test".to_owned(),
+        route: ActiveSonarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(sonarr_config_1),
+      },
+      TabRoute {
+        title: "Radarr 1".to_owned(),
+        route: ActiveRadarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(radarr_config_2),
+      },
+      TabRoute {
+        title: "Radarr Test".to_owned(),
+        route: ActiveRadarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(radarr_config_1),
+      },
+      TabRoute {
+        title: "Sonarr 1".to_owned(),
+        route: ActiveSonarrBlock::default().into(),
+        contextual_help: None,
+        config: Some(sonarr_config_2),
+      },
+    ];
 
-    assert_eq!(app.navigation_stack, vec![DEFAULT_ROUTE]);
-    assert!(app.network_tx.is_none());
+    let app = App::new(
+      mpsc::channel::<NetworkEvent>(500).0,
+      config,
+      CancellationToken::new(),
+    );
+
+    assert_is_empty!(app.navigation_stack);
+    assert_eq!(app.get_current_route(), ActiveSonarrBlock::default().into());
+    assert_some!(app.network_tx);
     assert!(!app.cancellation_token.is_cancelled());
+    assert!(app.is_first_render);
     assert_eq!(app.error, HorizontallyScrollableText::default());
     assert_eq!(app.server_tabs.index, 0);
-    assert_eq!(
-      app.server_tabs.tabs,
-      vec![
-        TabRoute {
-          title: "Radarr",
-          route: ActiveRadarrBlock::Movies.into(),
-          help: format!(
-            "<↑↓> scroll | ←→ change tab | {}  ",
-            build_context_clue_string(&SERVARR_CONTEXT_CLUES)
-          ),
-          contextual_help: None,
-        },
-        TabRoute {
-          title: "Sonarr",
-          route: Route::Sonarr,
-          help: format!("{}  ", build_context_clue_string(&SERVARR_CONTEXT_CLUES)),
-          contextual_help: None,
-        },
-      ]
-    );
+    assert_eq!(app.server_tabs.tabs, expected_tab_routes);
     assert_eq!(app.tick_until_poll, 400);
     assert_eq!(app.ticks_until_scroll, 4);
     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_app_default() {
+    let app = App::default();
+
+    assert_is_empty!(app.navigation_stack);
+    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.tick_until_poll, 400);
+    assert_eq!(app.ticks_until_scroll, 4);
+    assert_eq!(app.tick_count, 0);
+    assert!(!app.is_loading);
+    assert!(!app.is_routing);
+    assert!(!app.should_refresh);
+    assert!(!app.ignore_special_keys_for_textbox_input);
+    assert!(!app.cli_mode);
   }
 
   #[test]
   fn test_navigation_stack_methods() {
-    let mut app = App::default();
+    let mut app = App::test_default();
+    let default_route = app.server_tabs.tabs.first().unwrap().route;
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
 
     app.push_navigation_stack(ActiveRadarrBlock::Downloads.into());
 
-    assert_eq!(
-      app.get_current_route(),
-      &ActiveRadarrBlock::Downloads.into()
-    );
+    assert_eq!(app.get_current_route(), ActiveRadarrBlock::Downloads.into());
     assert!(app.is_routing);
 
     app.is_routing = false;
@@ -68,20 +124,20 @@ mod tests {
 
     assert_eq!(
       app.get_current_route(),
-      &ActiveRadarrBlock::Collections.into()
+      ActiveRadarrBlock::Collections.into()
     );
     assert!(app.is_routing);
 
     app.is_routing = false;
     app.pop_navigation_stack();
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
     assert!(app.is_routing);
 
     app.is_routing = false;
     app.pop_navigation_stack();
 
-    assert_eq!(app.get_current_route(), &DEFAULT_ROUTE);
+    assert_eq!(app.get_current_route(), default_route);
     assert!(app.is_routing);
   }
 
@@ -90,7 +146,7 @@ mod tests {
     let mut app = App {
       is_loading: true,
       should_refresh: false,
-      ..App::default()
+      ..App::test_default()
     };
     app.cancellation_token.cancel();
 
@@ -108,7 +164,7 @@ mod tests {
   fn test_reset_tick_count() {
     let mut app = App {
       tick_count: 2,
-      ..App::default()
+      ..App::test_default()
     };
 
     app.reset_tick_count();
@@ -118,28 +174,38 @@ mod tests {
 
   #[test]
   fn test_reset() {
+    let radarr_data = RadarrData {
+      version: "test".into(),
+      ..RadarrData::default()
+    };
+    let sonarr_data = SonarrData {
+      version: "test".into(),
+      ..SonarrData::default()
+    };
+    let data = Data {
+      radarr_data,
+      sonarr_data,
+    };
     let mut app = App {
       tick_count: 2,
       error: "Test error".to_owned().into(),
-      data: Data {
-        radarr_data: RadarrData {
-          version: "test".to_owned(),
-          ..RadarrData::default()
-        },
-      },
-      ..App::default()
+      is_first_render: false,
+      data,
+      ..App::test_default()
     };
 
     app.reset();
 
     assert_eq!(app.tick_count, 0);
     assert_eq!(app.error, HorizontallyScrollableText::default());
+    assert!(app.is_first_render);
     assert!(app.data.radarr_data.version.is_empty());
+    assert!(app.data.sonarr_data.version.is_empty());
   }
 
   #[test]
   fn test_handle_error() {
-    let mut app = App::default();
+    let mut app = App::test_default();
     let test_string = "Testing";
 
     app.handle_error(anyhow!(test_string));
@@ -158,7 +224,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);
@@ -181,12 +247,13 @@ mod tests {
     let mut app = App {
       tick_until_poll: 2,
       network_tx: Some(sync_network_tx),
-      ..App::default()
+      is_first_render: true,
+      ..App::test_default()
     };
 
     assert_eq!(app.tick_count, 0);
 
-    app.on_tick(true).await;
+    app.on_tick().await;
 
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
@@ -202,16 +269,24 @@ 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(),
-      RadarrEvent::GetOverview.into()
+      RadarrEvent::GetDiskSpace.into()
     );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
       RadarrEvent::GetStatus.into()
     );
+    assert_eq!(
+      sync_network_rx.recv().await.unwrap(),
+      RadarrEvent::GetQualityProfiles.into()
+    );
+    assert_eq!(
+      sync_network_rx.recv().await.unwrap(),
+      RadarrEvent::GetTags.into()
+    );
     assert_eq!(
       sync_network_rx.recv().await.unwrap(),
       RadarrEvent::GetMovies.into()
@@ -227,10 +302,10 @@ mod tests {
       tick_until_poll: 2,
       tick_count: 2,
       is_routing: true,
-      ..App::default()
+      ..App::test_default()
     };
 
-    app.on_tick(false).await;
+    app.on_tick().await;
     assert!(!app.is_routing);
   }
 
@@ -240,21 +315,303 @@ mod tests {
       tick_until_poll: 2,
       tick_count: 2,
       should_refresh: true,
-      ..App::default()
+      ..App::test_default()
     };
 
-    app.on_tick(false).await;
+    app.on_tick().await;
     assert!(!app.should_refresh);
   }
 
   #[test]
-  fn test_radarr_config_default() {
-    let radarr_config = RadarrConfig::default();
+  fn test_app_config_default() {
+    let app_config = AppConfig::default();
 
-    assert_eq!(radarr_config.host, Some("localhost".to_string()));
-    assert_eq!(radarr_config.port, Some(7878));
-    assert_eq!(radarr_config.uri, None);
-    assert!(radarr_config.api_token.is_empty());
-    assert_eq!(radarr_config.ssl_cert_path, None);
+    assert_none!(app_config.radarr);
+    assert_none!(app_config.sonarr);
+  }
+
+  #[test]
+  fn test_servarr_config_default() {
+    let servarr_config = ServarrConfig::default();
+
+    assert_none!(servarr_config.name);
+    assert_some_eq_x!(&servarr_config.host, "localhost");
+    assert_none!(servarr_config.port);
+    assert_none!(servarr_config.uri);
+    assert_none!(servarr_config.weight);
+    assert_some_eq_x!(&servarr_config.api_token, "");
+    assert_none!(servarr_config.api_token_file);
+    assert_none!(servarr_config.ssl_cert_path);
+    assert_none!(servarr_config.custom_headers);
+  }
+
+  #[test]
+  fn serialize_header_map_basic() {
+    let mut header_map = HeaderMap::new();
+    header_map.insert(
+      HeaderName::from_static("x-api-key"),
+      HeaderValue::from_static("abc123"),
+    );
+    header_map.insert(
+      HeaderName::from_static("header-1"),
+      HeaderValue::from_static("test"),
+    );
+
+    let config = ServarrConfig {
+      custom_headers: Some(header_map),
+      ..ServarrConfig::default()
+    };
+
+    let v: Value = serde_json::to_value(&config).expect("serialize ok");
+    let custom = v.get("custom_headers").unwrap();
+    assert!(custom.is_object());
+    let obj = custom.as_object().unwrap();
+
+    assert_some_eq_x!(obj.get("x-api-key"), "abc123");
+    assert_some_eq_x!(obj.get("header-1"), "test");
+
+    assert_none!(obj.get("X-Api-Key"));
+    assert_none!(obj.get("HEADER-1"));
+  }
+
+  #[test]
+  fn serialize_header_map_none_is_null() {
+    let config = ServarrConfig::default();
+    let v: Value = serde_json::to_value(&config).expect("serialize ok");
+    assert!(v.get("custom_headers").unwrap().is_null());
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_is_present() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION", "localhost") };
+    let yaml_data = r#"
+      host: ${TEST_VAR_DESERIALIZE_OPTION}
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.host, "localhost");
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION") };
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_does_not_overwrite_non_env_value() {
+    unsafe { std::env::set_var("TEST_VAR_DESERIALIZE_OPTION_NO_OVERWRITE", "localhost") };
+    let yaml_data = r#"
+      host: www.example.com
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_some_eq_x!(&config.host, "www.example.com");
+    unsafe { std::env::remove_var("TEST_VAR_DESERIALIZE_OPTION_NO_OVERWRITE") };
+  }
+
+  #[test]
+  fn test_deserialize_optional_env_var_empty() {
+    let yaml_data = r#"
+      api_token: "test123"
+    "#;
+
+    let config: ServarrConfig = serde_yaml::from_str(yaml_data).unwrap();
+
+    assert_none!(config.port);
+  }
+
+  #[test]
+  #[serial]
+  fn test_deserialize_optional_env_var_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_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 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_cert_path: Some(\"{ssl_cert_path}\"), custom_headers: Some({{\"x-custom-header\": \"value\"}}) }}"
+    );
+    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),
+      custom_headers: Some(custom_headers),
+    };
+
+    assert_str_eq!(format!("{servarr_config:?}"), expected_str);
   }
 }

src/app/context_clues.rs

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

src/app/context_clues_tests.rs

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

src/app/key_binding.rs

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

src/app/key_binding_tests.rs

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

src/app/mod.rs

@@ -1,32 +1,40 @@
-use std::process;
-
-use anyhow::anyhow;
+use anyhow::{Error, Result, anyhow};
 use colored::Colorize;
+use itertools::Itertools;
 use log::{debug, error};
+use regex::Regex;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::{fs, process};
 use tokio::sync::mpsc::Sender;
 use tokio_util::sync::CancellationToken;
+use veil::Redact;
 
-use crate::app::context_clues::{build_context_clue_string, SERVARR_CONTEXT_CLUES};
+use crate::cli::Command;
 use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
+use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SonarrData};
+use crate::models::servarr_models::KeybindingItem;
+use crate::models::stateful_table::StatefulTable;
 use crate::models::{HorizontallyScrollableText, Route, TabRoute, TabState};
 use crate::network::NetworkEvent;
 
 #[cfg(test)]
-#[path = "app_tests.rs"]
 mod app_tests;
 pub mod context_clues;
 pub mod key_binding;
 mod key_binding_tests;
 pub mod radarr;
-
-const DEFAULT_ROUTE: Route = Route::Radarr(ActiveRadarrBlock::Movies, None);
+pub mod sonarr;
 
 pub struct App<'a> {
   navigation_stack: Vec<Route>,
   network_tx: Option<Sender<NetworkEvent>>,
-  cancellation_token: CancellationToken,
+  pub cancellation_token: CancellationToken,
+  pub is_first_render: bool,
   pub server_tabs: TabState,
+  pub keymapping_table: Option<StatefulTable<KeybindingItem>>,
   pub error: HorizontallyScrollableText,
   pub tick_until_poll: u64,
   pub ticks_until_scroll: u64,
@@ -34,21 +42,85 @@ pub struct App<'a> {
   pub is_routing: bool,
   pub is_loading: bool,
   pub should_refresh: bool,
-  pub should_ignore_quit_key: bool,
-  pub config: AppConfig,
+  pub ignore_special_keys_for_textbox_input: bool,
+  pub cli_mode: bool,
   pub data: Data<'a>,
 }
 
-impl<'a> App<'a> {
+impl App<'_> {
   pub fn new(
     network_tx: Sender<NetworkEvent>,
     config: AppConfig,
     cancellation_token: CancellationToken,
   ) -> Self {
+    let mut server_tabs = Vec::new();
+
+    if let Some(radarr_configs) = config.radarr {
+      let mut unnamed_idx = 0;
+      let radarr_tabs = radarr_configs.into_iter().map(|radarr_config| {
+        let name = if let Some(name) = radarr_config.name.clone() {
+          name
+        } else {
+          unnamed_idx += 1;
+          format!("Radarr {unnamed_idx}")
+        };
+
+        TabRoute {
+          title: name,
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(radarr_config),
+        }
+      });
+      server_tabs.extend(radarr_tabs);
+    }
+
+    if let Some(sonarr_configs) = config.sonarr {
+      let mut unnamed_idx = 0;
+      let sonarr_tabs = sonarr_configs.into_iter().map(|sonarr_config| {
+        let name = if let Some(name) = sonarr_config.name.clone() {
+          name
+        } else {
+          unnamed_idx += 1;
+          format!("Sonarr {unnamed_idx}")
+        };
+
+        TabRoute {
+          title: name,
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(sonarr_config),
+        }
+      });
+      server_tabs.extend(sonarr_tabs);
+    }
+
+    let weight_sorted_tabs = server_tabs
+      .into_iter()
+      .sorted_by(|tab1, tab2| {
+        Ord::cmp(
+          tab1
+            .config
+            .as_ref()
+            .unwrap()
+            .weight
+            .as_ref()
+            .unwrap_or(&1000),
+          tab2
+            .config
+            .as_ref()
+            .unwrap()
+            .weight
+            .as_ref()
+            .unwrap_or(&1000),
+        )
+      })
+      .collect();
+
     App {
       network_tx: Some(network_tx),
-      config,
       cancellation_token,
+      server_tabs: TabState::new(weight_sorted_tabs),
       ..App::default()
     }
   }
@@ -60,12 +132,12 @@ impl<'a> App<'a> {
       self.is_loading = true;
     }
 
-    if let Some(network_tx) = &self.network_tx {
-      if let Err(e) = network_tx.send(action).await {
-        self.is_loading = false;
-        error!("Failed to send event. {e:?}");
-        self.handle_error(anyhow!(e));
-      }
+    if let Some(network_tx) = &self.network_tx
+      && let Err(e) = network_tx.send(action).await
+    {
+      self.is_loading = false;
+      error!("Failed to send event. {e:?}");
+      self.handle_error(anyhow!(e));
     }
   }
 
@@ -73,26 +145,29 @@ impl<'a> App<'a> {
     self.tick_count = 0;
   }
 
-  // Allowing this code for now since we'll eventually be implementing additional Servarr support and we'll need it then
   #[allow(dead_code)]
   pub fn reset(&mut self) {
     self.reset_tick_count();
     self.error = HorizontallyScrollableText::default();
+    self.is_first_render = true;
     self.data = Data::default();
   }
 
-  pub fn handle_error(&mut self, error: anyhow::Error) {
+  pub fn handle_error(&mut self, error: Error) {
     if self.error.text.is_empty() {
       self.error = error.to_string().into();
     }
   }
 
-  pub async fn on_tick(&mut self, is_first_render: bool) {
-    if self.tick_count % self.tick_until_poll == 0 || self.is_routing || self.should_refresh {
-      if let Route::Radarr(active_radarr_block, _) = self.get_current_route() {
-        self
-          .radarr_on_tick(*active_radarr_block, is_first_render)
-          .await;
+  pub async fn on_tick(&mut self) {
+    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,
+        _ => (),
       }
 
       self.is_routing = false;
@@ -109,7 +184,7 @@ impl<'a> App<'a> {
 
   pub fn pop_navigation_stack(&mut self) {
     self.is_routing = true;
-    if self.navigation_stack.len() > 1 {
+    if !self.navigation_stack.is_empty() {
       self.navigation_stack.pop();
     }
   }
@@ -127,99 +202,321 @@ impl<'a> App<'a> {
     self.push_navigation_stack(route);
   }
 
-  pub fn get_current_route(&self) -> &Route {
-    self.navigation_stack.last().unwrap_or(&DEFAULT_ROUTE)
+  pub fn get_current_route(&self) -> Route {
+    *self.navigation_stack.last().unwrap_or(
+      &self
+        .server_tabs
+        .tabs
+        .first()
+        .expect("At least one server tab must exist")
+        .route,
+    )
   }
 }
 
-impl<'a> Default for App<'a> {
+impl Default for App<'_> {
   fn default() -> Self {
     App {
-      navigation_stack: vec![DEFAULT_ROUTE],
+      navigation_stack: Vec::new(),
       network_tx: None,
       cancellation_token: CancellationToken::new(),
+      keymapping_table: None,
       error: HorizontallyScrollableText::default(),
-      server_tabs: TabState::new(vec![
-        TabRoute {
-          title: "Radarr",
-          route: ActiveRadarrBlock::Movies.into(),
-          help: format!(
-            "<↑↓> scroll | ←→ change tab | {}  ",
-            build_context_clue_string(&SERVARR_CONTEXT_CLUES)
-          ),
-          contextual_help: None,
-        },
-        TabRoute {
-          title: "Sonarr",
-          route: Route::Sonarr,
-          help: format!("{}  ", build_context_clue_string(&SERVARR_CONTEXT_CLUES)),
-          contextual_help: None,
-        },
-      ]),
+      is_first_render: true,
+      server_tabs: TabState::new(Vec::new()),
       tick_until_poll: 400,
       ticks_until_scroll: 4,
       tick_count: 0,
       is_loading: false,
       is_routing: false,
       should_refresh: false,
-      should_ignore_quit_key: false,
-      config: AppConfig::default(),
+      ignore_special_keys_for_textbox_input: false,
+      cli_mode: false,
       data: Data::default(),
     }
   }
 }
 
+#[cfg(test)]
+impl App<'_> {
+  pub fn test_default() -> Self {
+    App {
+      server_tabs: TabState::new(vec![
+        TabRoute {
+          title: "Radarr".to_owned(),
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Sonarr".to_owned(),
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+      ]),
+      ..App::default()
+    }
+  }
+
+  pub fn test_default_fully_populated() -> Self {
+    App {
+      data: Data {
+        radarr_data: RadarrData::test_default_fully_populated(),
+        sonarr_data: SonarrData::test_default_fully_populated(),
+      },
+      server_tabs: TabState::new(vec![
+        TabRoute {
+          title: "Radarr".to_owned(),
+          route: ActiveRadarrBlock::Movies.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+        TabRoute {
+          title: "Sonarr".to_owned(),
+          route: ActiveSonarrBlock::Series.into(),
+          contextual_help: None,
+          config: Some(ServarrConfig::default()),
+        },
+      ]),
+      ..App::default()
+    }
+  }
+}
+
 #[derive(Default)]
 pub struct Data<'a> {
   pub radarr_data: RadarrData<'a>,
+  pub sonarr_data: SonarrData<'a>,
 }
 
-pub trait ServarrConfig {
-  fn validate(&self);
-}
-
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct AppConfig {
-  pub radarr: RadarrConfig,
+  pub theme: Option<String>,
+  pub radarr: Option<Vec<ServarrConfig>>,
+  pub sonarr: Option<Vec<ServarrConfig>>,
 }
 
-impl ServarrConfig for AppConfig {
-  fn validate(&self) {
-    self.radarr.validate();
-  }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct RadarrConfig {
-  pub host: Option<String>,
-  pub port: Option<u16>,
-  pub uri: Option<String>,
-  pub api_token: String,
-  pub ssl_cert_path: Option<String>,
-}
-
-impl ServarrConfig for RadarrConfig {
-  fn validate(&self) {
-    if self.host.is_none() && self.uri.is_none() {
-      log_and_print_error("'host' or 'uri' is required for Radarr configuration".to_owned());
+impl AppConfig {
+  pub fn validate(&self) {
+    if self.radarr.is_none() && self.sonarr.is_none() {
+      log_and_print_error(
+        "No Servarr configuration provided in the specified configuration file".to_owned(),
+      );
       process::exit(1);
     }
+
+    if let Some(radarr_configs) = &self.radarr {
+      radarr_configs.iter().for_each(|config| config.validate());
+    }
+
+    if let Some(sonarr_configs) = &self.sonarr {
+      sonarr_configs.iter().for_each(|config| config.validate());
+    }
+  }
+
+  pub fn verify_config_present_for_cli(&self, command: &Command) {
+    let msg = |servarr: &str| {
+      log_and_print_error(format!(
+        "{servarr} configuration missing; Unable to run any {servarr} commands."
+      ))
+    };
+    match command {
+      Command::Radarr(_) if self.radarr.is_none() => {
+        msg("Radarr");
+        process::exit(1);
+      }
+      Command::Sonarr(_) if self.sonarr.is_none() => {
+        msg("Sonarr");
+        process::exit(1);
+      }
+      _ => (),
+    }
+  }
+
+  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();
+      }
+    }
   }
 }
 
-impl Default for RadarrConfig {
+#[derive(Redact, Deserialize, Serialize, Clone, PartialEq, Eq)]
+pub struct ServarrConfig {
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub name: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub host: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_u16_env_var")]
+  pub port: Option<u16>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub uri: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_u16_env_var")]
+  pub weight: Option<u16>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  #[redact]
+  pub api_token: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  pub api_token_file: Option<String>,
+  #[serde(default, deserialize_with = "deserialize_optional_env_var")]
+  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>,
+}
+
+impl ServarrConfig {
+  fn validate(&self) {
+    if self.host.is_none() && self.uri.is_none() {
+      log_and_print_error("'host' or 'uri' is required for configuration".to_owned());
+      process::exit(1);
+    }
+
+    if self.api_token_file.is_none() && self.api_token.is_none() {
+      log_and_print_error(
+        "'api_token' or 'api_token_path' is required for configuration".to_owned(),
+      );
+      process::exit(1);
+    }
+  }
+
+  pub fn post_process_initialization(&mut self) {
+    if let Some(api_token_file) = self.api_token_file.as_ref() {
+      if !PathBuf::from(api_token_file).exists() {
+        log_and_print_error(format!(
+          "The specified {api_token_file} API token file does not exist"
+        ));
+        process::exit(1);
+      }
+
+      let api_token = fs::read_to_string(api_token_file)
+        .map_err(|e| anyhow!(e))
+        .unwrap();
+      self.api_token = Some(api_token.trim().to_owned());
+    }
+  }
+}
+
+impl Default for ServarrConfig {
   fn default() -> Self {
-    RadarrConfig {
+    ServarrConfig {
+      name: None,
       host: Some("localhost".to_string()),
-      port: Some(7878),
+      port: None,
       uri: None,
-      api_token: "".to_string(),
+      weight: None,
+      api_token: Some(String::new()),
+      api_token_file: None,
       ssl_cert_path: None,
+      custom_headers: 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_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_u16_env_var<'de, D>(deserializer: D) -> Result<Option<u16>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let s: Option<String> = Option::deserialize(deserializer)?;
+  match s {
+    Some(value) => {
+      let interpolated = interpolate_env_vars(&value);
+      interpolated
+        .parse::<u16>()
+        .map(Some)
+        .map_err(serde::de::Error::custom)
+    }
+    None => Ok(None),
+  }
+}
+
+fn interpolate_env_vars(s: &str) -> String {
+  let result = s.to_string();
+  let scrubbing_regex = Regex::new(r#"[\s{}!$^()\[\]\\|`'"]+"#).unwrap();
+  let var_regex = Regex::new(r"\$\{(.*?)}").unwrap();
+
+  var_regex
+    .replace_all(s, |caps: &regex::Captures<'_>| {
+      if let Some(mat) = caps.get(1)
+        && let Ok(value) = std::env::var(mat.as_str())
+      {
+        return scrubbing_regex.replace_all(&value, "").to_string();
+      }
+
+      scrubbing_regex.replace_all(&result, "").to_string()
+    })
+    .to_string()
+}

src/app/radarr/mod.rs

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

src/app/radarr/radarr_context_clues.rs

@@ -1,13 +1,25 @@
-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,
+};
 use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+use crate::models::Route;
+use crate::models::servarr_data::radarr::radarr_data::{
+  ADD_MOVIE_BLOCKS, ActiveRadarrBlock, EDIT_COLLECTION_BLOCKS, EDIT_INDEXER_BLOCKS,
+  EDIT_MOVIE_BLOCKS, INDEXER_SETTINGS_BLOCKS, MOVIE_DETAILS_BLOCKS,
+};
 
 #[cfg(test)]
 #[path = "radarr_context_clues_tests.rs"]
 mod radarr_context_clues_tests;
 
-pub static LIBRARY_CONTEXT_CLUES: [ContextClue; 10] = [
+pub static LIBRARY_CONTEXT_CLUES: [ContextClue; 11] = [
   (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (
+    DEFAULT_KEYBINDINGS.toggle_monitoring,
+    DEFAULT_KEYBINDINGS.toggle_monitoring.desc,
+  ),
   (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
   (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
   (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
@@ -35,60 +47,6 @@ pub static COLLECTIONS_CONTEXT_CLUES: [ContextClue; 8] = [
   (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
 ];
 
-pub static DOWNLOADS_CONTEXT_CLUES: [ContextClue; 2] = [
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-];
-
-pub static BLOCKLIST_CONTEXT_CLUES: [ContextClue; 5] = [
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
-  (DEFAULT_KEYBINDINGS.submit, "details"),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (DEFAULT_KEYBINDINGS.clear, "clear blocklist"),
-];
-
-pub static ROOT_FOLDERS_CONTEXT_CLUES: [ContextClue; 3] = [
-  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
-pub static INDEXERS_CONTEXT_CLUES: [ContextClue; 6] = [
-  (DEFAULT_KEYBINDINGS.submit, "edit indexer"),
-  (
-    DEFAULT_KEYBINDINGS.settings,
-    DEFAULT_KEYBINDINGS.settings.desc,
-  ),
-  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
-  (DEFAULT_KEYBINDINGS.test, "test indexer"),
-  (DEFAULT_KEYBINDINGS.test_all, "test all indexers"),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
-pub static SYSTEM_CONTEXT_CLUES: [ContextClue; 5] = [
-  (DEFAULT_KEYBINDINGS.tasks, "open tasks"),
-  (DEFAULT_KEYBINDINGS.events, "open events"),
-  (DEFAULT_KEYBINDINGS.logs, "open logs"),
-  (DEFAULT_KEYBINDINGS.update, "open updates"),
-  (
-    DEFAULT_KEYBINDINGS.refresh,
-    DEFAULT_KEYBINDINGS.refresh.desc,
-  ),
-];
-
 pub static MOVIE_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
   (
     DEFAULT_KEYBINDINGS.refresh,
@@ -96,11 +54,14 @@ pub static MOVIE_DETAILS_CONTEXT_CLUES: [ContextClue; 5] = [
   ),
   (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
-  (DEFAULT_KEYBINDINGS.search, "auto search"),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
   (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 
-pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 6] = [
+pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 7] = [
   (
     DEFAULT_KEYBINDINGS.refresh,
     DEFAULT_KEYBINDINGS.refresh.desc,
@@ -108,29 +69,77 @@ pub static MANUAL_MOVIE_SEARCH_CONTEXT_CLUES: [ContextClue; 6] = [
   (DEFAULT_KEYBINDINGS.update, DEFAULT_KEYBINDINGS.update.desc),
   (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
   (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
-  (DEFAULT_KEYBINDINGS.search, "auto search"),
+  (
+    DEFAULT_KEYBINDINGS.auto_search,
+    DEFAULT_KEYBINDINGS.auto_search.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
   (DEFAULT_KEYBINDINGS.esc, DEFAULT_KEYBINDINGS.esc.desc),
 ];
 
-pub static MANUAL_MOVIE_SEARCH_CONTEXTUAL_CONTEXT_CLUES: [ContextClue; 1] =
-  [(DEFAULT_KEYBINDINGS.submit, "details")];
-
 pub static ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES: [ContextClue; 2] = [
   (DEFAULT_KEYBINDINGS.submit, "details"),
   (DEFAULT_KEYBINDINGS.esc, "edit search"),
 ];
 
-pub static CONFIRMATION_PROMPT_CONTEXT_CLUES: [ContextClue; 2] = [
-  (DEFAULT_KEYBINDINGS.confirm, "submit"),
-  (DEFAULT_KEYBINDINGS.esc, "cancel"),
-];
-
 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; 2] = [
+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)
+      }
+      ActiveRadarrBlock::AddMoviePrompt
+      | ActiveRadarrBlock::AddMovieSelectMonitor
+      | ActiveRadarrBlock::AddMovieSelectMinimumAvailability
+      | ActiveRadarrBlock::AddMovieSelectQualityProfile
+      | ActiveRadarrBlock::AddMovieSelectRootFolder
+      | ActiveRadarrBlock::AddMovieTagsInput
+      | ActiveRadarrBlock::SystemTaskStartConfirmPrompt => Some(&CONFIRMATION_PROMPT_CONTEXT_CLUES),
+      _ if ADD_MOVIE_BLOCKS.contains(&active_radarr_block) => {
+        Some(&ADD_MOVIE_SEARCH_RESULTS_CONTEXT_CLUES)
+      }
+      ActiveRadarrBlock::CollectionDetails => Some(&COLLECTION_DETAILS_CONTEXT_CLUES),
+      _ => app
+        .data
+        .radarr_data
+        .main_tabs
+        .get_active_route_contextual_help(),
+    }
+  }
+}

src/app/radarr/radarr_context_clues_tests.rs

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

src/app/sonarr/mod.rs

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

src/app/sonarr/sonarr_context_clues.rs

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

src/app/sonarr/sonarr_context_clues_tests.rs

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

src/app/sonarr/sonarr_tests.rs

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

src/cli/cli_tests.rs

@@ -2,29 +2,38 @@
 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::{
-    app::App,
-    cli::{handle_command, mutex_flags_or_option, radarr::RadarrCommand},
-    models::{
-      radarr_models::{BlocklistItem, BlocklistResponse, RadarrSerdeable},
-      Serdeable,
-    },
-    network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
     Cli,
+    app::App,
+    cli::{handle_command, mutex_flags_or_option, radarr::RadarrCommand, sonarr::SonarrCommand},
+    models::{
+      Serdeable,
+      radarr_models::{
+        BlocklistItem as RadarrBlocklistItem, BlocklistResponse as RadarrBlocklistResponse,
+        RadarrSerdeable,
+      },
+      sonarr_models::{
+        BlocklistItem as SonarrBlocklistItem, BlocklistResponse as SonarrBlocklistResponse,
+        SonarrSerdeable,
+      },
+    },
+    network::{
+      MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent, sonarr_network::SonarrEvent,
+    },
   };
   use pretty_assertions::assert_eq;
 
-  #[test]
-  fn test_radarr_subcommand_requires_subcommand() {
-    let result = Cli::command().try_get_matches_from(["managarr", "radarr"]);
+  #[rstest]
+  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
@@ -36,14 +45,21 @@ mod tests {
     let result =
       Cli::command().try_get_matches_from(["managarr", "radarr", "get", "all-indexer-settings"]);
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
+  }
+
+  #[test]
+  fn test_sonarr_subcommand_delegates_to_sonarr() {
+    let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "series"]);
+
+    assert_ok!(&result);
   }
 
   #[test]
   fn test_completions_requires_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions"]);
 
-    assert!(result.is_err());
+    assert_err!(&result);
     assert_eq!(
       result.unwrap_err().kind(),
       ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
@@ -54,7 +70,7 @@ mod tests {
   fn test_completions_invalid_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions", "test"]);
 
-    assert!(result.is_err());
+    assert_err!(&result);
     assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
   }
 
@@ -62,7 +78,7 @@ mod tests {
   fn test_completions_satisfied_with_argument() {
     let result = Cli::command().try_get_matches_from(["managarr", "completions", "bash"]);
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
   }
 
   #[rstest]
@@ -106,8 +122,8 @@ mod tests {
       .times(1)
       .returning(|_| {
         Ok(Serdeable::Radarr(RadarrSerdeable::BlocklistResponse(
-          BlocklistResponse {
-            records: vec![BlocklistItem::default()],
+          RadarrBlocklistResponse {
+            records: vec![RadarrBlocklistItem::default()],
           },
         )))
       });
@@ -120,11 +136,42 @@ mod tests {
           json!({"testResponse": "response"}),
         )))
       });
-    let app_arc = Arc::new(Mutex::new(App::default()));
-    let claer_blocklist_command = RadarrCommand::ClearBlocklist.into();
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
+    let clear_blocklist_command = RadarrCommand::ClearBlocklist.into();
 
-    let result = handle_command(&app_arc, claer_blocklist_command, &mut mock_network).await;
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
 
-    assert!(result.is_ok());
+    assert_ok!(&result);
+  }
+
+  #[tokio::test]
+  async fn test_cli_handler_delegates_sonarr_commands_to_the_sonarr_cli_handler() {
+    let mut mock_network = MockNetworkTrait::new();
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(SonarrEvent::GetBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Sonarr(SonarrSerdeable::BlocklistResponse(
+          SonarrBlocklistResponse {
+            records: vec![SonarrBlocklistItem::default()],
+          },
+        )))
+      });
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(SonarrEvent::ClearBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+          json!({"testResponse": "response"}),
+        )))
+      });
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
+    let clear_blocklist_command = SonarrCommand::ClearBlocklist.into();
+
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
+
+    assert_ok!(&result);
   }
 }

src/cli/mod.rs

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

src/cli/radarr/add_command_handler.rs

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

src/cli/radarr/add_command_handler_tests.rs

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

src/cli/radarr/delete_command_handler.rs

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

src/cli/radarr/delete_command_handler_tests.rs

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

src/cli/radarr/edit_command_handler.rs

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

src/cli/radarr/edit_command_handler_tests.rs

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

src/cli/radarr/get_command_handler.rs

@@ -1,14 +1,13 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use clap::{command, Subcommand};
+use clap::{Subcommand, command};
 use tokio::sync::Mutex;
 
 use crate::{
   app::App,
   cli::{CliCommandHandler, Command},
-  execute_network_event,
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 
 use super::RadarrCommand;
@@ -72,28 +71,52 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrGetCommand> for RadarrGetCommandHan
     }
   }
 
-  async fn handle(self) -> Result<()> {
-    match self.command {
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
       RadarrGetCommand::AllIndexerSettings => {
-        execute_network_event!(self, RadarrEvent::GetAllIndexerSettings);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetAllIndexerSettings.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrGetCommand::HostConfig => {
-        execute_network_event!(self, RadarrEvent::GetHostConfig);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetHostConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrGetCommand::MovieDetails { movie_id } => {
-        execute_network_event!(self, RadarrEvent::GetMovieDetails(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetMovieDetails(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrGetCommand::MovieHistory { movie_id } => {
-        execute_network_event!(self, RadarrEvent::GetMovieHistory(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetMovieHistory(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrGetCommand::SecurityConfig => {
-        execute_network_event!(self, RadarrEvent::GetSecurityConfig);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetSecurityConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrGetCommand::SystemStatus => {
-        execute_network_event!(self, RadarrEvent::GetStatus);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetStatus.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/get_command_handler_tests.rs

@@ -1,12 +1,13 @@
 #[cfg(test)]
-mod test {
-  use clap::error::ErrorKind;
+mod tests {
   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]
   fn test_radarr_get_command_from() {
@@ -26,7 +27,7 @@ mod test {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "get", "all-indexer-settings"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -34,7 +35,7 @@ mod test {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "get", "host-config"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -42,7 +43,7 @@ mod test {
       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
@@ -60,7 +61,7 @@ mod test {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -68,7 +69,7 @@ mod test {
       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
@@ -86,7 +87,7 @@ mod test {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -94,7 +95,7 @@ mod test {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "get", "security-config"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[test]
@@ -102,7 +103,7 @@ mod test {
       let result =
         Cli::command().try_get_matches_from(["managarr", "radarr", "get", "system-status"]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 
@@ -116,11 +117,11 @@ mod test {
     use crate::{
       app::App,
       cli::{
-        radarr::get_command_handler::{RadarrGetCommand, RadarrGetCommandHandler},
         CliCommandHandler,
+        radarr::get_command_handler::{RadarrGetCommand, RadarrGetCommandHandler},
       },
-      models::{radarr_models::RadarrSerdeable, Serdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     #[tokio::test]
@@ -137,7 +138,7 @@ mod test {
             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(
@@ -148,7 +149,7 @@ mod test {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -163,7 +164,7 @@ mod test {
             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 =
@@ -171,7 +172,7 @@ mod test {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -181,7 +182,7 @@ mod test {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetMovieDetails(Some(expected_movie_id)).into(),
+          RadarrEvent::GetMovieDetails(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -189,7 +190,7 @@ mod test {
             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 =
@@ -197,7 +198,7 @@ mod test {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -207,7 +208,7 @@ mod test {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetMovieHistory(Some(expected_movie_id)).into(),
+          RadarrEvent::GetMovieHistory(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -215,7 +216,7 @@ mod test {
             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 =
@@ -223,7 +224,7 @@ mod test {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -238,7 +239,7 @@ mod test {
             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 =
@@ -246,7 +247,7 @@ mod test {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -261,7 +262,7 @@ mod test {
             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 =
@@ -269,7 +270,7 @@ mod test {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/radarr/list_command_handler.rs

@@ -1,14 +1,13 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use clap::{command, Subcommand};
+use clap::{Subcommand, command};
 use tokio::sync::Mutex;
 
 use crate::{
   app::App,
   cli::{CliCommandHandler, Command},
-  execute_network_event,
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 
 use super::RadarrCommand;
@@ -24,7 +23,12 @@ 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 = "List all Radarr indexers")]
   Indexers,
   #[command(about = "Fetch Radarr logs")]
@@ -56,7 +60,7 @@ pub enum RadarrListCommand {
   RootFolders,
   #[command(about = "List all Radarr tags")]
   Tags,
-  #[command(about = "List tasks")]
+  #[command(about = "List all Radarr tasks")]
   Tasks,
   #[command(about = "List all Radarr updates")]
   Updates,
@@ -87,19 +91,42 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
     }
   }
 
-  async fn handle(self) -> Result<()> {
-    match self.command {
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
       RadarrListCommand::Blocklist => {
-        execute_network_event!(self, RadarrEvent::GetBlocklist);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Collections => {
-        execute_network_event!(self, RadarrEvent::GetCollections);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetCollections.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-      RadarrListCommand::Downloads => {
-        execute_network_event!(self, RadarrEvent::GetDownloads);
+      RadarrListCommand::Downloads { count } => {
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetDownloads(count).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      RadarrListCommand::DiskSpace => {
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetDiskSpace.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Indexers => {
-        execute_network_event!(self, RadarrEvent::GetIndexers);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetIndexers.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Logs {
         events,
@@ -107,45 +134,75 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
       } => {
         let logs = self
           .network
-          .handle_network_event(RadarrEvent::GetLogs(Some(events)).into())
+          .handle_network_event(RadarrEvent::GetLogs(events).into())
           .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;
 
-          let json = serde_json::to_string_pretty(&log_lines)?;
-          println!("{}", json);
+          serde_json::to_string_pretty(log_lines)?
         } else {
-          let json = serde_json::to_string_pretty(&logs)?;
-          println!("{}", json);
+          serde_json::to_string_pretty(&logs)?
         }
       }
       RadarrListCommand::Movies => {
-        execute_network_event!(self, RadarrEvent::GetMovies);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetMovies.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::MovieCredits { movie_id } => {
-        execute_network_event!(self, RadarrEvent::GetMovieCredits(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetMovieCredits(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::QualityProfiles => {
-        execute_network_event!(self, RadarrEvent::GetQualityProfiles);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetQualityProfiles.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::QueuedEvents => {
-        execute_network_event!(self, RadarrEvent::GetQueuedEvents);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetQueuedEvents.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::RootFolders => {
-        execute_network_event!(self, RadarrEvent::GetRootFolders);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetRootFolders.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Tags => {
-        execute_network_event!(self, RadarrEvent::GetTags);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetTags.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Tasks => {
-        execute_network_event!(self, RadarrEvent::GetTasks);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetTasks.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrListCommand::Updates => {
-        execute_network_event!(self, RadarrEvent::GetUpdates);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetUpdates.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/list_command_handler_tests.rs

@@ -1,12 +1,13 @@
 #[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]
   fn test_radarr_list_command_from() {
@@ -28,7 +29,7 @@ mod tests {
       #[values(
         "blocklist",
         "collections",
-        "downloads",
+        "disk-space",
         "indexers",
         "movies",
         "quality-profiles",
@@ -42,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]
@@ -50,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);
     }
 
@@ -78,11 +88,27 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
 
-      if let Some(Command::Radarr(RadarrCommand::List(refresh_command))) = result.unwrap().command {
-        assert_eq!(refresh_command, expected_args);
-      }
+      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]
@@ -93,11 +119,13 @@ 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 {
-        assert_eq!(refresh_command, expected_args);
-      }
+      let Some(Command::Radarr(RadarrCommand::List(refresh_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(refresh_command, expected_args);
     }
   }
 
@@ -113,14 +141,14 @@ mod tests {
     use crate::{
       app::App,
       cli::radarr::list_command_handler::{RadarrListCommand, RadarrListCommandHandler},
-      models::{radarr_models::RadarrSerdeable, Serdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
+      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)]
     #[case(RadarrListCommand::QualityProfiles, RadarrEvent::GetQualityProfiles)]
@@ -130,7 +158,7 @@ mod tests {
     #[case(RadarrListCommand::Tasks, RadarrEvent::GetTasks)]
     #[case(RadarrListCommand::Updates, RadarrEvent::GetUpdates)]
     #[tokio::test]
-    async fn test_handle_list_blocklist_command(
+    async fn test_handle_list_command(
       #[case] list_command: RadarrListCommand,
       #[case] expected_radarr_event: RadarrEvent,
     ) {
@@ -144,13 +172,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]
@@ -160,7 +188,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetMovieCredits(Some(expected_movie_id)).into(),
+          RadarrEvent::GetMovieCredits(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -168,7 +196,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 =
@@ -176,7 +204,33 @@ 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]
@@ -186,7 +240,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetLogs(Some(expected_events)).into(),
+          RadarrEvent::GetLogs(expected_events).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -194,7 +248,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,
@@ -204,7 +258,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/radarr/mod.rs

@@ -12,10 +12,9 @@ use tokio::sync::Mutex;
 use crate::app::App;
 
 use crate::cli::CliCommandHandler;
-use crate::execute_network_event;
-use crate::models::radarr_models::{ReleaseDownloadBody, TaskName};
-use crate::network::radarr_network::RadarrEvent;
+use crate::models::radarr_models::{RadarrReleaseDownloadBody, RadarrTaskName};
 use crate::network::NetworkTrait;
+use crate::network::radarr_network::RadarrEvent;
 use anyhow::Result;
 
 use super::Command;
@@ -86,7 +85,7 @@ pub enum RadarrCommand {
   ManualSearch {
     #[arg(
       long,
-      help = "The Radarr ID of the movie whose releases you wish to fetch and list",
+      help = "The Radarr ID of the movie whose releases you wish to fetch",
       required = true
     )]
     movie_id: i64,
@@ -108,7 +107,7 @@ pub enum RadarrCommand {
       value_enum,
       required = true
     )]
-    task_name: TaskName,
+    task_name: RadarrTaskName,
   },
   #[command(
     about = "Test the indexer with the given ID. Note that a successful test returns an empty JSON body; i.e. '{}'"
@@ -117,8 +116,19 @@ pub enum RadarrCommand {
     #[arg(long, help = "The ID of the indexer to test", required = true)]
     indexer_id: i64,
   },
-  #[command(about = "Test all indexers")]
+  #[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(
@@ -155,8 +165,8 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrCommand> for RadarrCliHandler<'a, '
     }
   }
 
-  async fn handle(self) -> Result<()> {
-    match self.command {
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
       RadarrCommand::Add(add_command) => {
         RadarrAddCommandHandler::with(self.app, add_command, self.network)
           .handle()
@@ -192,41 +202,81 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrCommand> for RadarrCliHandler<'a, '
           .network
           .handle_network_event(RadarrEvent::GetBlocklist.into())
           .await?;
-        execute_network_event!(self, RadarrEvent::ClearBlocklist);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::ClearBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::DownloadRelease {
         guid,
         indexer_id,
         movie_id,
       } => {
-        let params = ReleaseDownloadBody {
+        let params = RadarrReleaseDownloadBody {
           guid,
           indexer_id,
           movie_id,
         };
-        execute_network_event!(self, RadarrEvent::DownloadRelease(Some(params)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::DownloadRelease(params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::ManualSearch { movie_id } => {
         println!("Searching for releases. This may take a minute...");
-        execute_network_event!(self, RadarrEvent::GetReleases(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::GetReleases(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::SearchNewMovie { query } => {
-        execute_network_event!(self, RadarrEvent::SearchNewMovie(Some(query)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::SearchNewMovie(query).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::StartTask { task_name } => {
-        execute_network_event!(self, RadarrEvent::StartTask(Some(task_name)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::StartTask(task_name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::TestIndexer { indexer_id } => {
-        execute_network_event!(self, RadarrEvent::TestIndexer(Some(indexer_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::TestIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrCommand::TestAllIndexers => {
-        execute_network_event!(self, RadarrEvent::TestAllIndexers);
+        println!("Testing all Radarr indexers. This may take a minute...");
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::TestAllIndexers.into())
+          .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 } => {
-        execute_network_event!(self, RadarrEvent::TriggerAutomaticSearch(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::TriggerAutomaticSearch(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/radarr_command_tests.rs

@@ -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,10 +28,10 @@ mod tests {
     ) {
       let result = Cli::command().try_get_matches_from(["managarr", "radarr", subcommand]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[test]
     fn test_download_release_requires_movie_id() {
       let result = Cli::command().try_get_matches_from([
         "managarr",
@@ -43,14 +43,14 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
       );
     }
 
-    #[rstest]
+    #[test]
     fn test_download_release_requires_guid() {
       let result = Cli::command().try_get_matches_from([
         "managarr",
@@ -62,14 +62,14 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
       );
     }
 
-    #[rstest]
+    #[test]
     fn test_download_release_requires_indexer_id() {
       let result = Cli::command().try_get_matches_from([
         "managarr",
@@ -81,7 +81,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(
         result.unwrap_err().kind(),
         ErrorKind::MissingRequiredArgument
@@ -102,14 +102,14 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[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 +126,14 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[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,21 +150,21 @@ mod tests {
         "halo",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[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
       );
     }
 
-    #[rstest]
+    #[test]
     fn test_start_task_task_name_validation() {
       let result = Cli::command().try_get_matches_from([
         "managarr",
@@ -174,7 +174,7 @@ mod tests {
         "test",
       ]);
 
-      assert!(result.is_err());
+      assert_err!(&result);
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
@@ -188,14 +188,14 @@ mod tests {
         "application-check-update",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[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,15 +212,40 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
-    #[rstest]
+    #[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]
     fn test_trigger_automatic_search_requires_movie_id() {
       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 +262,7 @@ mod tests {
         "1",
       ]);
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 
@@ -251,22 +276,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::{
-        radarr_models::{
-          BlocklistItem, BlocklistResponse, IndexerSettings, RadarrSerdeable, ReleaseDownloadBody,
-          TaskName,
-        },
         Serdeable,
+        radarr_models::{
+          BlocklistItem, BlocklistResponse, IndexerSettings, RadarrReleaseDownloadBody,
+          RadarrSerdeable, RadarrTaskName,
+        },
       },
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     #[tokio::test]
@@ -292,19 +317,19 @@ mod tests {
             json!({"testResponse": "response"}),
           )))
         });
-      let app_arc = Arc::new(Mutex::new(App::default()));
-      let claer_blocklist_command = RadarrCommand::ClearBlocklist;
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let clear_blocklist_command = RadarrCommand::ClearBlocklist;
 
-      let result = RadarrCliHandler::with(&app_arc, claer_blocklist_command, &mut mock_network)
+      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_download_release_command() {
-      let expected_release_download_body = ReleaseDownloadBody {
+      let expected_release_download_body = RadarrReleaseDownloadBody {
         guid: "guid".to_owned(),
         indexer_id: 1,
         movie_id: 1,
@@ -313,7 +338,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DownloadRelease(Some(expected_release_download_body)).into(),
+          RadarrEvent::DownloadRelease(expected_release_download_body).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -321,7 +346,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 +357,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -342,7 +367,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetReleases(Some(expected_movie_id)).into(),
+          RadarrEvent::GetReleases(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -350,14 +375,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]
@@ -367,7 +392,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::SearchNewMovie(Some(expected_search_query)).into(),
+          RadarrEvent::SearchNewMovie(expected_search_query).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -375,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 search_new_movie_command = RadarrCommand::SearchNewMovie {
         query: "halo".to_owned(),
       };
@@ -384,17 +409,17 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
     async fn test_start_task_command() {
-      let expected_task_name = TaskName::ApplicationCheckUpdate;
+      let expected_task_name = RadarrTaskName::ApplicationCheckUpdate;
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::StartTask(Some(expected_task_name)).into(),
+          RadarrEvent::StartTask(expected_task_name).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -402,16 +427,16 @@ 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: TaskName::ApplicationCheckUpdate,
+        task_name: RadarrTaskName::ApplicationCheckUpdate,
       };
 
       let result = RadarrCliHandler::with(&app_arc, start_task_command, &mut mock_network)
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -421,7 +446,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::TestIndexer(Some(expected_indexer_id)).into(),
+          RadarrEvent::TestIndexer(expected_indexer_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -429,14 +454,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 +476,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]
@@ -468,7 +519,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::TriggerAutomaticSearch(Some(expected_movie_id)).into(),
+          RadarrEvent::TriggerAutomaticSearch(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -476,7 +527,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 +538,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -505,7 +556,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 +565,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -524,7 +575,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::DeleteBlocklistItem(Some(expected_blocklist_item_id)).into(),
+          RadarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -532,7 +583,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 +594,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -584,7 +635,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditAllIndexerSettings(Some(expected_edit_all_indexer_settings)).into(),
+          RadarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -592,7 +643,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 +666,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -632,7 +683,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 +695,7 @@ mod tests {
       .handle()
       .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -654,7 +705,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetMovieCredits(Some(expected_movie_id)).into(),
+          RadarrEvent::GetMovieCredits(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -662,7 +713,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 +721,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
 
     #[tokio::test]
@@ -680,7 +731,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::UpdateAndScan(Some(expected_movie_id)).into(),
+          RadarrEvent::UpdateAndScan(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -688,7 +739,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 +747,7 @@ mod tests {
         .handle()
         .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/radarr/refresh_command_handler.rs

@@ -7,8 +7,7 @@ use tokio::sync::Mutex;
 use crate::{
   app::App,
   cli::{CliCommandHandler, Command},
-  execute_network_event,
-  network::{radarr_network::RadarrEvent, NetworkTrait},
+  network::{NetworkTrait, radarr_network::RadarrEvent},
 };
 
 use super::RadarrCommand;
@@ -19,7 +18,7 @@ mod refresh_command_handler_tests;
 
 #[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
 pub enum RadarrRefreshCommand {
-  #[command(about = "Refresh all movie data for all movies in your library")]
+  #[command(about = "Refresh all movie data for all movies in your Radarr library")]
   AllMovies,
   #[command(about = "Refresh movie data and scan disk for the movie with the given ID")]
   Movie {
@@ -63,22 +62,38 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrRefreshCommand>
     }
   }
 
-  async fn handle(self) -> Result<()> {
-    match self.command {
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
       RadarrRefreshCommand::AllMovies => {
-        execute_network_event!(self, RadarrEvent::UpdateAllMovies);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::UpdateAllMovies.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrRefreshCommand::Collections => {
-        execute_network_event!(self, RadarrEvent::UpdateCollections);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::UpdateCollections.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrRefreshCommand::Downloads => {
-        execute_network_event!(self, RadarrEvent::UpdateDownloads);
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::UpdateDownloads.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
       RadarrRefreshCommand::Movie { movie_id } => {
-        execute_network_event!(self, RadarrEvent::UpdateAndScan(Some(movie_id)));
+        let resp = self
+          .network
+          .handle_network_event(RadarrEvent::UpdateAndScan(movie_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
       }
-    }
+    };
 
-    Ok(())
+    Ok(result)
   }
 }

src/cli/radarr/refresh_command_handler_tests.rs

@@ -1,12 +1,13 @@
 #[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]
   fn test_radarr_refresh_command_from() {
@@ -30,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
@@ -50,13 +51,13 @@ 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))) =
-        result.unwrap().command
-      {
-        assert_eq!(refresh_command, expected_args);
-      }
+      let Some(Command::Radarr(RadarrCommand::Refresh(refresh_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(refresh_command, expected_args);
     }
   }
 
@@ -72,8 +73,8 @@ mod tests {
     use crate::{
       app::App,
       cli::radarr::refresh_command_handler::{RadarrRefreshCommand, RadarrRefreshCommandHandler},
-      models::{radarr_models::RadarrSerdeable, Serdeable},
-      network::{radarr_network::RadarrEvent, MockNetworkTrait, NetworkEvent},
+      models::{Serdeable, radarr_models::RadarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, radarr_network::RadarrEvent},
     };
 
     #[rstest]
@@ -81,7 +82,7 @@ mod tests {
     #[case(RadarrRefreshCommand::Collections, RadarrEvent::UpdateCollections)]
     #[case(RadarrRefreshCommand::Downloads, RadarrEvent::UpdateDownloads)]
     #[tokio::test]
-    async fn test_handle_list_blocklist_command(
+    async fn test_handle_refresh_command(
       #[case] refresh_command: RadarrRefreshCommand,
       #[case] expected_radarr_event: RadarrEvent,
     ) {
@@ -95,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]
@@ -111,7 +112,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::UpdateAndScan(Some(expected_movie_id)).into(),
+          RadarrEvent::UpdateAndScan(expected_movie_id).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -119,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 =
@@ -127,7 +128,7 @@ mod tests {
           .handle()
           .await;
 
-      assert!(result.is_ok());
+      assert_ok!(&result);
     }
   }
 }

src/cli/sonarr/add_command_handler.rs

@@ -0,0 +1,176 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::{ArgAction, Subcommand};
+use tokio::sync::Mutex;
+
+use super::SonarrCommand;
+use crate::models::servarr_models::AddRootFolderBody;
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  models::sonarr_models::{AddSeriesBody, AddSeriesOptions, SeriesMonitor, SeriesType},
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+#[cfg(test)]
+#[path = "add_command_handler_tests.rs"]
+mod add_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrAddCommand {
+  #[command(about = "Add a new series to your Sonarr library")]
+  Series {
+    #[arg(
+      long,
+      help = "The TVDB ID of the series you wish to add to your library",
+      required = true
+    )]
+    tvdb_id: i64,
+    #[arg(long, help = "The title of the series", required = true)]
+    title: String,
+    #[arg(
+      long,
+      help = "The root folder path where all series data and metadata should live",
+      required = true
+    )]
+    root_folder_path: String,
+    #[arg(
+      long,
+      help = "The ID of the quality profile to use for this series",
+      required = true
+    )]
+    quality_profile_id: i64,
+    #[arg(
+      long,
+      help = "The ID of the language profile to use for this series",
+      required = true
+    )]
+    language_profile_id: i64,
+    #[arg(
+      long,
+      help = "The type of series",
+      value_enum,
+      default_value_t = SeriesType::default()
+    )]
+    series_type: SeriesType,
+    #[arg(long, help = "Disable monitoring for this series")]
+    disable_monitoring: bool,
+    #[arg(long, help = "Don't use season folders for this series")]
+    disable_season_folders: bool,
+    #[arg(
+      long,
+      help = "Tag IDs to tag the series with", 
+      value_parser,
+      action = ArgAction::Append
+    )]
+    tag: Vec<i64>,
+    #[arg(
+      long,
+      help = "What Sonarr should monitor", 
+      value_enum,
+      default_value_t = SeriesMonitor::default()
+    )]
+    monitor: SeriesMonitor,
+    #[arg(
+      long,
+      help = "Tell Sonarr to not start a search for this series once it's added to your library"
+    )]
+    no_search_for_series: bool,
+  },
+  #[command(about = "Add a new root folder")]
+  RootFolder {
+    #[arg(long, help = "The path of the new root folder", required = true)]
+    root_folder_path: String,
+  },
+  #[command(about = "Add new tag")]
+  Tag {
+    #[arg(long, help = "The name of the tag to be added", required = true)]
+    name: String,
+  },
+}
+
+impl From<SonarrAddCommand> for Command {
+  fn from(value: SonarrAddCommand) -> Self {
+    Command::Sonarr(SonarrCommand::Add(value))
+  }
+}
+
+pub(super) struct SonarrAddCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrAddCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrAddCommand> for SonarrAddCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrAddCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrAddCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrAddCommand::Series {
+        tvdb_id,
+        title,
+        root_folder_path,
+        quality_profile_id,
+        language_profile_id,
+        series_type,
+        disable_monitoring,
+        disable_season_folders,
+        tag: tags,
+        monitor,
+        no_search_for_series,
+      } => {
+        let body = AddSeriesBody {
+          tvdb_id,
+          title,
+          monitored: !disable_monitoring,
+          root_folder_path,
+          quality_profile_id,
+          language_profile_id,
+          series_type: series_type.to_string(),
+          season_folder: !disable_season_folders,
+          tags,
+          tag_input_string: None,
+          add_options: AddSeriesOptions {
+            monitor: monitor.to_string(),
+            search_for_cutoff_unmet_episodes: !no_search_for_series,
+            search_for_missing_episodes: !no_search_for_series,
+          },
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::AddSeries(body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrAddCommand::RootFolder { root_folder_path } => {
+        let add_root_folder_body = AddRootFolderBody {
+          path: root_folder_path,
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::AddRootFolder(add_root_folder_body).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrAddCommand::Tag { name } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::AddTag(name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+    Ok(result)
+  }
+}

src/cli/sonarr/add_command_handler_tests.rs

@@ -0,0 +1,592 @@
+#[cfg(test)]
+mod tests {
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+  use pretty_assertions::assert_eq;
+
+  use crate::{
+    Cli,
+    cli::{
+      Command,
+      sonarr::{SonarrCommand, add_command_handler::SonarrAddCommand},
+    },
+  };
+
+  #[test]
+  fn test_sonarr_add_command_from() {
+    let command = SonarrAddCommand::Tag {
+      name: String::new(),
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::Add(command)));
+  }
+
+  mod cli {
+    use crate::models::sonarr_models::{SeriesMonitor, SeriesType};
+
+    use super::*;
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[test]
+    fn test_add_root_folder_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "add", "root-folder"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_root_folder_success() {
+      let expected_args = SonarrAddCommand::RootFolder {
+        root_folder_path: "/nfs/test".to_owned(),
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "root-folder",
+        "--root-folder-path",
+        "/nfs/test",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_series_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "add", "series"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_series_requires_tvdb_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--title",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_series_requires_title() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--tvdb-id",
+        "1",
+        "--root-folder-path",
+        "test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_series_requires_root_folder_path() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--tvdb-id",
+        "1",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--title",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_series_requires_quality_profile_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--tvdb-id",
+        "1",
+        "--root-folder-path",
+        "test",
+        "--language-profile-id",
+        "1",
+        "--title",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_series_requires_language_profile_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--tvdb-id",
+        "1",
+        "--root-folder-path",
+        "test",
+        "--quality-profile-id",
+        "1",
+        "--title",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[rstest]
+    fn test_add_series_assert_argument_flags_require_args(
+      #[values("--series-type", "--tag", "--monitor")] flag: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--tvdb-id",
+        "1",
+        "--title",
+        "test",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        flag,
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_add_series_all_arguments_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--title",
+        "test",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--tvdb-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_add_series_series_type_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--tvdb-id",
+        "1",
+        "--title",
+        "test",
+        "--series-type",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_add_series_monitor_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--tvdb-id",
+        "--title",
+        "test",
+        "1",
+        "--monitor",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_add_series_defaults() {
+      let expected_args = SonarrAddCommand::Series {
+        tvdb_id: 1,
+        title: "test".to_owned(),
+        root_folder_path: "/test".to_owned(),
+        quality_profile_id: 1,
+        language_profile_id: 1,
+        series_type: SeriesType::default(),
+        disable_monitoring: false,
+        disable_season_folders: false,
+        tag: vec![],
+        monitor: SeriesMonitor::default(),
+        no_search_for_series: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--title",
+        "test",
+        "--tvdb-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+      let Some(Command::Sonarr(SonarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_series_tags_is_repeatable() {
+      let expected_args = SonarrAddCommand::Series {
+        tvdb_id: 1,
+        title: "test".to_owned(),
+        root_folder_path: "/test".to_owned(),
+        quality_profile_id: 1,
+        language_profile_id: 1,
+        series_type: SeriesType::default(),
+        disable_monitoring: false,
+        disable_season_folders: false,
+        tag: vec![1, 2],
+        monitor: SeriesMonitor::default(),
+        no_search_for_series: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--tvdb-id",
+        "1",
+        "--title",
+        "test",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+      let Some(Command::Sonarr(SonarrCommand::Add(add_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(add_command, expected_args);
+    }
+
+    #[test]
+    fn test_add_series_all_args_defined() {
+      let expected_args = SonarrAddCommand::Series {
+        tvdb_id: 1,
+        title: "test".to_owned(),
+        root_folder_path: "/test".to_owned(),
+        quality_profile_id: 1,
+        language_profile_id: 1,
+        series_type: SeriesType::Anime,
+        disable_monitoring: true,
+        disable_season_folders: true,
+        tag: vec![1, 2],
+        monitor: SeriesMonitor::Future,
+        no_search_for_series: true,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "add",
+        "series",
+        "--root-folder-path",
+        "/test",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--series-type",
+        "anime",
+        "--disable-monitoring",
+        "--disable-season-folders",
+        "--tvdb-id",
+        "1",
+        "--title",
+        "test",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+        "--monitor",
+        "future",
+        "--no-search-for-series",
+      ]);
+
+      assert_ok!(&result);
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "add", "tag"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_add_tag_success() {
+      let expected_args = SonarrAddCommand::Tag {
+        name: "test".to_owned(),
+      };
+
+      let result = Cli::try_parse_from(["managarr", "sonarr", "add", "tag", "--name", "test"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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::{CliCommandHandler, sonarr::add_command_handler::SonarrAddCommandHandler},
+      models::{
+        Serdeable,
+        sonarr_models::{
+          AddSeriesBody, AddSeriesOptions, SeriesMonitor, SeriesType, SonarrSerdeable,
+        },
+      },
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    use super::*;
+    use mockall::predicate::eq;
+
+    use crate::models::servarr_models::AddRootFolderBody;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    #[tokio::test]
+    async fn test_handle_add_root_folder_command() {
+      let expected_root_folder_path = "/nfs/test".to_owned();
+      let expected_add_root_folder_body = AddRootFolderBody {
+        path: expected_root_folder_path.clone(),
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::AddRootFolder(expected_add_root_folder_body.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_root_folder_command = SonarrAddCommand::RootFolder {
+        root_folder_path: expected_root_folder_path,
+      };
+
+      let result =
+        SonarrAddCommandHandler::with(&app_arc, add_root_folder_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_add_series_command() {
+      let expected_add_series_body = AddSeriesBody {
+        tvdb_id: 1,
+        title: "test".to_owned(),
+        root_folder_path: "/test".to_owned(),
+        quality_profile_id: 1,
+        language_profile_id: 1,
+        series_type: "anime".to_owned(),
+        monitored: false,
+        tags: vec![1, 2],
+        tag_input_string: None,
+        season_folder: false,
+        add_options: AddSeriesOptions {
+          monitor: "future".to_owned(),
+          search_for_cutoff_unmet_episodes: false,
+          search_for_missing_episodes: false,
+        },
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::AddSeries(expected_add_series_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_series_command = SonarrAddCommand::Series {
+        tvdb_id: 1,
+        title: "test".to_owned(),
+        root_folder_path: "/test".to_owned(),
+        quality_profile_id: 1,
+        language_profile_id: 1,
+        series_type: SeriesType::Anime,
+        disable_monitoring: true,
+        disable_season_folders: true,
+        tag: vec![1, 2],
+        monitor: SeriesMonitor::Future,
+        no_search_for_series: true,
+      };
+
+      let result = SonarrAddCommandHandler::with(&app_arc, add_series_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>(
+          SonarrEvent::AddTag(expected_tag_name.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_tag_command = SonarrAddCommand::Tag {
+        name: expected_tag_name,
+      };
+
+      let result = SonarrAddCommandHandler::with(&app_arc, add_tag_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/delete_command_handler.rs

@@ -0,0 +1,156 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  models::sonarr_models::DeleteSeriesParams,
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "delete_command_handler_tests.rs"]
+mod delete_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrDeleteCommand {
+  #[command(about = "Delete the specified item from the Sonarr 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 download")]
+  Download {
+    #[arg(long, help = "The ID of the download to delete", required = true)]
+    download_id: i64,
+  },
+  #[command(about = "Delete the specified episode file from disk")]
+  EpisodeFile {
+    #[arg(long, help = "The ID of the episode file to delete", required = true)]
+    episode_file_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 a series from your Sonarr library")]
+  Series {
+    #[arg(long, help = "The ID of the series to delete", required = true)]
+    series_id: i64,
+    #[arg(long, help = "Delete the series files from disk as well")]
+    delete_files_from_disk: bool,
+    #[arg(long, help = "Add a list exclusion for this series")]
+    add_list_exclusion: bool,
+  },
+  #[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<SonarrDeleteCommand> for Command {
+  fn from(value: SonarrDeleteCommand) -> Self {
+    Command::Sonarr(SonarrCommand::Delete(value))
+  }
+}
+
+pub(super) struct SonarrDeleteCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrDeleteCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrDeleteCommand> for SonarrDeleteCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrDeleteCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrDeleteCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let resp = match self.command {
+      SonarrDeleteCommand::BlocklistItem { blocklist_item_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteBlocklistItem(blocklist_item_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::Download { download_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteDownload(download_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::EpisodeFile { episode_file_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteEpisodeFile(episode_file_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::Indexer { indexer_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::RootFolder { root_folder_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteRootFolder(root_folder_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::Series {
+        series_id,
+        delete_files_from_disk,
+        add_list_exclusion,
+      } => {
+        let delete_series_params = DeleteSeriesParams {
+          id: series_id,
+          delete_series_files: delete_files_from_disk,
+          add_list_exclusion,
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteSeries(delete_series_params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDeleteCommand::Tag { tag_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DeleteTag(tag_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(resp)
+  }
+}

src/cli/sonarr/delete_command_handler_tests.rs

@@ -0,0 +1,500 @@
+#[cfg(test)]
+mod tests {
+  use crate::{
+    Cli,
+    cli::{
+      Command,
+      sonarr::{SonarrCommand, delete_command_handler::SonarrDeleteCommand},
+    },
+  };
+  use clap::{CommandFactory, Parser, error::ErrorKind};
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_delete_command_from() {
+    let command = SonarrDeleteCommand::BlocklistItem {
+      blocklist_item_id: 1,
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::Delete(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_delete_blocklist_item_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "delete", "blocklist-item"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_blocklist_item_success() {
+      let expected_args = SonarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "blocklist-item",
+        "--blocklist-item-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "delete", "download"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_download_success() {
+      let expected_args = SonarrDeleteCommand::Download { download_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "download",
+        "--download-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_episode_file_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "delete", "episode-file"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_episode_file_success() {
+      let expected_args = SonarrDeleteCommand::EpisodeFile { episode_file_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "episode-file",
+        "--episode-file-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "delete", "indexer"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_indexer_success() {
+      let expected_args = SonarrDeleteCommand::Indexer { indexer_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "indexer",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "delete", "root-folder"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_root_folder_success() {
+      let expected_args = SonarrDeleteCommand::RootFolder { root_folder_id: 1 };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "root-folder",
+        "--root-folder-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_series_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "delete", "series"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_series_defaults() {
+      let expected_args = SonarrDeleteCommand::Series {
+        series_id: 1,
+        delete_files_from_disk: false,
+        add_list_exclusion: false,
+      };
+
+      let result =
+        Cli::try_parse_from(["managarr", "sonarr", "delete", "series", "--series-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
+    #[test]
+    fn test_delete_series_all_args_defined() {
+      let expected_args = SonarrDeleteCommand::Series {
+        series_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "delete",
+        "series",
+        "--series-id",
+        "1",
+        "--delete-files-from-disk",
+        "--add-list-exclusion",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "delete", "tag"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_tag_success() {
+      let expected_args = SonarrDeleteCommand::Tag { tag_id: 1 };
+
+      let result = Cli::try_parse_from(["managarr", "sonarr", "delete", "tag", "--tag-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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,
+        sonarr::delete_command_handler::{SonarrDeleteCommand, SonarrDeleteCommandHandler},
+      },
+      models::{
+        Serdeable,
+        sonarr_models::{DeleteSeriesParams, SonarrSerdeable},
+      },
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[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>(
+          SonarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_blocklist_item_command = SonarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = SonarrDeleteCommandHandler::with(
+        &app_arc,
+        delete_blocklist_item_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>(
+          SonarrEvent::DeleteDownload(expected_download_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_download_command = SonarrDeleteCommand::Download { download_id: 1 };
+
+      let result =
+        SonarrDeleteCommandHandler::with(&app_arc, delete_download_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_episode_file_command() {
+      let expected_episode_file_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DeleteEpisodeFile(expected_episode_file_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_episode_file_command = SonarrDeleteCommand::EpisodeFile { episode_file_id: 1 };
+
+      let result =
+        SonarrDeleteCommandHandler::with(&app_arc, delete_episode_file_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>(
+          SonarrEvent::DeleteIndexer(expected_indexer_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_indexer_command = SonarrDeleteCommand::Indexer { indexer_id: 1 };
+
+      let result =
+        SonarrDeleteCommandHandler::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>(
+          SonarrEvent::DeleteRootFolder(expected_root_folder_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_root_folder_command = SonarrDeleteCommand::RootFolder { root_folder_id: 1 };
+
+      let result =
+        SonarrDeleteCommandHandler::with(&app_arc, delete_root_folder_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_delete_series_command() {
+      let expected_delete_series_params = DeleteSeriesParams {
+        id: 1,
+        delete_series_files: true,
+        add_list_exclusion: true,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DeleteSeries(expected_delete_series_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_series_command = SonarrDeleteCommand::Series {
+        series_id: 1,
+        delete_files_from_disk: true,
+        add_list_exclusion: true,
+      };
+
+      let result =
+        SonarrDeleteCommandHandler::with(&app_arc, delete_series_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>(
+          SonarrEvent::DeleteTag(expected_tag_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_tag_command = SonarrDeleteCommand::Tag { tag_id: 1 };
+
+      let result =
+        SonarrDeleteCommandHandler::with(&app_arc, delete_tag_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/download_command_handler.rs

@@ -0,0 +1,169 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  models::sonarr_models::SonarrReleaseDownloadBody,
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "download_command_handler_tests.rs"]
+mod download_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrDownloadCommand {
+  #[command(about = "Manually download the given series release for the specified series ID")]
+  Series {
+    #[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,
+    #[arg(
+      long,
+      help = "The series ID that the release is associated with",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(
+    about = "Manually download the given season release corresponding to the series specified with the series ID"
+  )]
+  Season {
+    #[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,
+    #[arg(
+      long,
+      help = "The series ID that the release is associated with",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(
+      long,
+      help = "The season number that the release corresponds to",
+      required = true
+    )]
+    season_number: i64,
+  },
+  #[command(about = "Manually download the given episode release for the specified episode ID")]
+  Episode {
+    #[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,
+    #[arg(
+      long,
+      help = "The episode ID that the release is associated with",
+      required = true
+    )]
+    episode_id: i64,
+  },
+}
+
+impl From<SonarrDownloadCommand> for Command {
+  fn from(value: SonarrDownloadCommand) -> Self {
+    Command::Sonarr(SonarrCommand::Download(value))
+  }
+}
+
+pub(super) struct SonarrDownloadCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrDownloadCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrDownloadCommand>
+  for SonarrDownloadCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrDownloadCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrDownloadCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrDownloadCommand::Series {
+        guid,
+        indexer_id,
+        series_id,
+      } => {
+        let params = SonarrReleaseDownloadBody {
+          guid,
+          indexer_id,
+          series_id: Some(series_id),
+          ..SonarrReleaseDownloadBody::default()
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DownloadRelease(params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDownloadCommand::Season {
+        guid,
+        indexer_id,
+        series_id,
+        season_number,
+      } => {
+        let params = SonarrReleaseDownloadBody {
+          guid,
+          indexer_id,
+          series_id: Some(series_id),
+          season_number: Some(season_number),
+          ..SonarrReleaseDownloadBody::default()
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DownloadRelease(params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrDownloadCommand::Episode {
+        guid,
+        indexer_id,
+        episode_id,
+      } => {
+        let params = SonarrReleaseDownloadBody {
+          guid,
+          indexer_id,
+          episode_id: Some(episode_id),
+          ..SonarrReleaseDownloadBody::default()
+        };
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::DownloadRelease(params).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/download_command_handler_tests.rs

@@ -0,0 +1,423 @@
+#[cfg(test)]
+mod tests {
+  use crate::{
+    Cli,
+    cli::{
+      Command,
+      sonarr::{SonarrCommand, download_command_handler::SonarrDownloadCommand},
+    },
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_download_command_from() {
+    let command = SonarrDownloadCommand::Series {
+      guid: "Test".to_owned(),
+      indexer_id: 1,
+      series_id: 1,
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::Download(command)));
+  }
+
+  mod cli {
+    use super::*;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_download_series_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "series",
+        "--indexer-id",
+        "1",
+        "--guid",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_series_requires_guid() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "series",
+        "--indexer-id",
+        "1",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_series_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "series",
+        "--guid",
+        "1",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_series_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "series",
+        "--guid",
+        "1",
+        "--series-id",
+        "1",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_download_season_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "season",
+        "--indexer-id",
+        "1",
+        "--season-number",
+        "1",
+        "--guid",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_season_requires_season_number() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "season",
+        "--indexer-id",
+        "1",
+        "--series-id",
+        "1",
+        "--guid",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_season_requires_guid() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "season",
+        "--indexer-id",
+        "1",
+        "--season-number",
+        "1",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_season_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "season",
+        "--guid",
+        "1",
+        "--season-number",
+        "1",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_season_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "season",
+        "--guid",
+        "1",
+        "--series-id",
+        "1",
+        "--season-number",
+        "1",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_download_episode_requires_episode_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "episode",
+        "--indexer-id",
+        "1",
+        "--guid",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_episode_requires_guid() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "episode",
+        "--indexer-id",
+        "1",
+        "--episode-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_episode_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "episode",
+        "--guid",
+        "1",
+        "--episode-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_download_episode_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "download",
+        "episode",
+        "--guid",
+        "1",
+        "--episode-id",
+        "1",
+        "--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::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        sonarr::download_command_handler::{SonarrDownloadCommand, SonarrDownloadCommandHandler},
+      },
+      models::{
+        Serdeable,
+        sonarr_models::{SonarrReleaseDownloadBody, SonarrSerdeable},
+      },
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_download_series_release_command() {
+      let expected_release_download_body = SonarrReleaseDownloadBody {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        series_id: Some(1),
+        ..SonarrReleaseDownloadBody::default()
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DownloadRelease(expected_release_download_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let download_release_command = SonarrDownloadCommand::Series {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        series_id: 1,
+      };
+
+      let result =
+        SonarrDownloadCommandHandler::with(&app_arc, download_release_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_download_season_release_command() {
+      let expected_release_download_body = SonarrReleaseDownloadBody {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        series_id: Some(1),
+        season_number: Some(1),
+        ..SonarrReleaseDownloadBody::default()
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DownloadRelease(expected_release_download_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let download_release_command = SonarrDownloadCommand::Season {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        series_id: 1,
+        season_number: 1,
+      };
+
+      let result =
+        SonarrDownloadCommandHandler::with(&app_arc, download_release_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_download_episode_release_command() {
+      let expected_release_download_body = SonarrReleaseDownloadBody {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        episode_id: Some(1),
+        ..SonarrReleaseDownloadBody::default()
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DownloadRelease(expected_release_download_body).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let download_release_command = SonarrDownloadCommand::Episode {
+        guid: "guid".to_owned(),
+        indexer_id: 1,
+        episode_id: 1,
+      };
+
+      let result =
+        SonarrDownloadCommandHandler::with(&app_arc, download_release_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/edit_command_handler.rs

@@ -0,0 +1,365 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::{ArgAction, ArgGroup, Subcommand};
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command, mutex_flags_or_option},
+  models::{
+    Serdeable,
+    servarr_models::EditIndexerParams,
+    sonarr_models::{EditSeriesParams, IndexerSettings, SeriesType, SonarrSerdeable},
+  },
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "edit_command_handler_tests.rs"]
+mod edit_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrEditCommand {
+  #[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 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 Sonarr that this indexer should be used when Sonarr periodically looks for releases via RSS Sync",
+      conflicts_with = "disable_rss"
+    )]
+    enable_rss: bool,
+    #[arg(
+      long,
+      help = "Disable using this indexer when Sonarr periodically looks for releases via RSS Sync",
+      conflicts_with = "enable_rss"
+    )]
+    disable_rss: bool,
+    #[arg(
+      long,
+      help = "Indicate to Sonarr that this indexer should be used when automatic searches are performed via the UI or by Sonarr",
+      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 Sonarr",
+      conflicts_with = "enable_automatic_search"
+    )]
+    disable_automatic_search: bool,
+    #[arg(
+      long,
+      help = "Indicate to Sonarr 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, Sonarr 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,
+  },
+  #[command(
+    about = "Edit preferences for the specified series",
+    group(
+      ArgGroup::new("edit_series")
+      .args([
+        "enable_monitoring",
+        "disable_monitoring",
+        "enable_season_folders",
+        "disable_season_folders",
+        "series_type",
+        "quality_profile_id",
+        "language_profile_id",
+        "root_folder_path",
+        "tag",
+        "clear_tags"
+      ]).required(true)
+      .multiple(true))
+  )]
+  Series {
+    #[arg(
+      long,
+      help = "The ID of the series whose settings you want to edit",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(
+      long,
+      help = "Enable monitoring of this series in Sonarr so Sonarr will automatically download this series if it is available",
+      conflicts_with = "disable_monitoring"
+    )]
+    enable_monitoring: bool,
+    #[arg(
+      long,
+      help = "Disable monitoring of this series so Sonarr does not automatically download the series if it is found to be available",
+      conflicts_with = "enable_monitoring"
+    )]
+    disable_monitoring: bool,
+    #[arg(
+      long,
+      help = "The minimum availability to monitor for this film",
+      value_enum
+    )]
+    #[arg(
+      long,
+      help = "Enable sorting episodes of this series into season folders",
+      conflicts_with = "disable_season_folders"
+    )]
+    enable_season_folders: bool,
+    #[arg(
+      long,
+      help = "Disable sorting episodes of this series into season folders",
+      conflicts_with = "enable_season_folders"
+    )]
+    disable_season_folders: bool,
+    #[arg(long, help = "The type of series", value_enum)]
+    series_type: Option<SeriesType>,
+    #[arg(long, help = "The ID of the quality profile to use for this series")]
+    quality_profile_id: Option<i64>,
+    #[arg(long, help = "The ID of the language profile to use for this series")]
+    language_profile_id: Option<i64>,
+    #[arg(
+      long,
+      help = "The root folder path where all film data and metadata should live"
+    )]
+    root_folder_path: Option<String>,
+    #[arg(
+      long,
+      help = "Tag IDs to tag this series with",
+      value_parser,
+      action = ArgAction::Append,
+      conflicts_with = "clear_tags"
+    )]
+    tag: Option<Vec<i64>>,
+    #[arg(long, help = "Clear all tags on this series", conflicts_with = "tag")]
+    clear_tags: bool,
+  },
+}
+
+impl From<SonarrEditCommand> for Command {
+  fn from(value: SonarrEditCommand) -> Self {
+    Command::Sonarr(SonarrCommand::Edit(value))
+  }
+}
+
+pub(super) struct SonarrEditCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrEditCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrEditCommand> for SonarrEditCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrEditCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrEditCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrEditCommand::AllIndexerSettings {
+        maximum_size,
+        minimum_age,
+        retention,
+        rss_sync_interval,
+      } => {
+        if let Serdeable::Sonarr(SonarrSerdeable::IndexerSettings(previous_indexer_settings)) = self
+          .network
+          .handle_network_event(SonarrEvent::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(SonarrEvent::EditAllIndexerSettings(params).into())
+            .await?;
+          "All indexer settings updated".to_owned()
+        } else {
+          String::new()
+        }
+      }
+      SonarrEditCommand::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(SonarrEvent::EditIndexer(edit_indexer_params).into())
+          .await?;
+        "Indexer updated".to_owned()
+      }
+      SonarrEditCommand::Series {
+        series_id,
+        enable_monitoring,
+        disable_monitoring,
+        enable_season_folders,
+        disable_season_folders,
+        series_type,
+        quality_profile_id,
+        language_profile_id,
+        root_folder_path,
+        tag,
+        clear_tags,
+      } => {
+        let monitored_value = mutex_flags_or_option(enable_monitoring, disable_monitoring);
+        let season_folders_value =
+          mutex_flags_or_option(enable_season_folders, disable_season_folders);
+        let edit_series_params = EditSeriesParams {
+          series_id,
+          monitored: monitored_value,
+          use_season_folders: season_folders_value,
+          series_type,
+          quality_profile_id,
+          language_profile_id,
+          root_folder_path,
+          tags: tag,
+          tag_input_string: None,
+          clear_tags,
+        };
+
+        self
+          .network
+          .handle_network_event(SonarrEvent::EditSeries(edit_series_params).into())
+          .await?;
+        "Series Updated".to_owned()
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/edit_command_handler_tests.rs

@@ -0,0 +1,886 @@
+#[cfg(test)]
+mod tests {
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, edit_command_handler::SonarrEditCommand},
+  };
+
+  #[test]
+  fn test_sonarr_edit_command_from() {
+    let command = SonarrEditCommand::AllIndexerSettings {
+      maximum_size: None,
+      minimum_age: None,
+      retention: None,
+      rss_sync_interval: None,
+    };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::Edit(command)));
+  }
+
+  mod cli {
+    use crate::{Cli, models::sonarr_models::SeriesType};
+
+    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", "sonarr", "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",
+        "sonarr",
+        "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 = SonarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: None,
+        retention: None,
+        rss_sync_interval: None,
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "all-indexer-settings",
+        "--maximum-size",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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 = SonarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: Some(1),
+        retention: Some(1),
+        rss_sync_interval: Some(1),
+      };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "all-indexer-settings",
+        "--maximum-size",
+        "1",
+        "--minimum-age",
+        "1",
+        "--retention",
+        "1",
+        "--rss-sync-interval",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "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 = SonarrEditCommand::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",
+        "sonarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--name",
+        "Test",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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 = SonarrEditCommand::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",
+        "sonarr",
+        "edit",
+        "indexer",
+        "--indexer-id",
+        "1",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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 = SonarrEditCommand::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",
+        "sonarr",
+        "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::Sonarr(SonarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_series_requires_arguments() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "edit", "series"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_series_with_series_id_still_requires_arguments() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_edit_series_monitoring_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--enable-monitoring",
+        "--disable-monitoring",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_series_season_folders_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--enable-season-folders",
+        "--disable-season-folders",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[test]
+    fn test_edit_series_tag_flags_conflict() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--tag",
+        "1",
+        "--clear-tags",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);
+    }
+
+    #[rstest]
+    fn test_edit_series_assert_argument_flags_require_args(
+      #[values(
+        "--series-type",
+        "--quality-profile-id",
+        "--language-profile-id",
+        "--root-folder-path",
+        "--tag"
+      )]
+      flag: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        flag,
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_series_series_type_validation() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--series-type",
+        "test",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_edit_series_only_requires_at_least_one_argument_plus_series_id() {
+      let expected_args = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        enable_season_folders: false,
+        disable_season_folders: false,
+        series_type: None,
+        quality_profile_id: None,
+        language_profile_id: None,
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: None,
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--root-folder-path",
+        "/nfs/test",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_series_tag_argument_is_repeatable() {
+      let expected_args = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        enable_season_folders: false,
+        disable_season_folders: false,
+        series_type: None,
+        quality_profile_id: None,
+        language_profile_id: None,
+        root_folder_path: None,
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Edit(edit_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(edit_command, expected_args);
+    }
+
+    #[test]
+    fn test_edit_series_all_arguments_defined() {
+      let expected_args = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: true,
+        disable_monitoring: false,
+        enable_season_folders: true,
+        disable_season_folders: false,
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_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",
+        "sonarr",
+        "edit",
+        "series",
+        "--series-id",
+        "1",
+        "--enable-monitoring",
+        "--enable-season-folders",
+        "--series-type",
+        "anime",
+        "--quality-profile-id",
+        "1",
+        "--language-profile-id",
+        "1",
+        "--root-folder-path",
+        "/nfs/test",
+        "--tag",
+        "1",
+        "--tag",
+        "2",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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::{
+      app::App,
+      cli::{
+        CliCommandHandler,
+        sonarr::edit_command_handler::{SonarrEditCommand, SonarrEditCommandHandler},
+      },
+      models::{
+        Serdeable,
+        servarr_models::EditIndexerParams,
+        sonarr_models::{EditSeriesParams, IndexerSettings, SeriesType, SonarrSerdeable},
+      },
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_edit_all_indexer_settings_command() {
+      let expected_edit_all_indexer_settings = IndexerSettings {
+        id: 1,
+        maximum_size: 1,
+        minimum_age: 1,
+        retention: 1,
+        rss_sync_interval: 1,
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::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>(
+          SonarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_all_indexer_settings_command = SonarrEditCommand::AllIndexerSettings {
+        maximum_size: Some(1),
+        minimum_age: Some(1),
+        retention: Some(1),
+        rss_sync_interval: Some(1),
+      };
+
+      let result = SonarrEditCommandHandler::with(
+        &app_arc,
+        edit_all_indexer_settings_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>(
+          SonarrEvent::EditIndexer(expected_edit_indexer_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_indexer_command = SonarrEditCommand::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 =
+        SonarrEditCommandHandler::with(&app_arc, edit_indexer_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_series_command() {
+      let expected_edit_series_params = EditSeriesParams {
+        series_id: 1,
+        monitored: Some(true),
+        use_season_folders: Some(true),
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_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>(
+          SonarrEvent::EditSeries(expected_edit_series_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_series_command = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: true,
+        disable_monitoring: false,
+        enable_season_folders: true,
+        disable_season_folders: false,
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = SonarrEditCommandHandler::with(&app_arc, edit_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_series_command_handles_disable_monitoring_flag_properly() {
+      let expected_edit_series_params = EditSeriesParams {
+        series_id: 1,
+        monitored: Some(false),
+        use_season_folders: Some(false),
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_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>(
+          SonarrEvent::EditSeries(expected_edit_series_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_series_command = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: true,
+        enable_season_folders: false,
+        disable_season_folders: true,
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = SonarrEditCommandHandler::with(&app_arc, edit_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_edit_series_command_no_monitoring_boolean_flags_returns_none_value() {
+      let expected_edit_series_params = EditSeriesParams {
+        series_id: 1,
+        monitored: None,
+        use_season_folders: None,
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_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>(
+          SonarrEvent::EditSeries(expected_edit_series_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_series_command = SonarrEditCommand::Series {
+        series_id: 1,
+        enable_monitoring: false,
+        disable_monitoring: false,
+        enable_season_folders: false,
+        disable_season_folders: false,
+        series_type: Some(SeriesType::Anime),
+        quality_profile_id: Some(1),
+        language_profile_id: Some(1),
+        root_folder_path: Some("/nfs/test".to_owned()),
+        tag: Some(vec![1, 2]),
+        clear_tags: false,
+      };
+
+      let result = SonarrEditCommandHandler::with(&app_arc, edit_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/get_command_handler.rs

@@ -0,0 +1,122 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "get_command_handler_tests.rs"]
+mod get_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrGetCommand {
+  #[command(about = "Get the shared settings for all indexers")]
+  AllIndexerSettings,
+  #[command(about = "Get detailed information for the episode with the given ID")]
+  EpisodeDetails {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the episode whose details you wish to fetch",
+      required = true
+    )]
+    episode_id: i64,
+  },
+  #[command(about = "Fetch the host config for your Sonarr instance")]
+  HostConfig,
+  #[command(about = "Fetch the security config for your Sonarr instance")]
+  SecurityConfig,
+  #[command(about = "Get detailed information for the series with the given ID")]
+  SeriesDetails {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose details you wish to fetch",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(about = "Get the system status")]
+  SystemStatus,
+}
+
+impl From<SonarrGetCommand> for Command {
+  fn from(value: SonarrGetCommand) -> Self {
+    Command::Sonarr(SonarrCommand::Get(value))
+  }
+}
+
+pub(super) struct SonarrGetCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrGetCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrGetCommand> for SonarrGetCommandHandler<'a, 'b> {
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrGetCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrGetCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrGetCommand::AllIndexerSettings => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetAllIndexerSettings.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrGetCommand::EpisodeDetails { episode_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetEpisodeDetails(episode_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrGetCommand::HostConfig => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetHostConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrGetCommand::SecurityConfig => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetSecurityConfig.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrGetCommand::SeriesDetails { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetSeriesDetails(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrGetCommand::SystemStatus => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetStatus.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/get_command_handler_tests.rs

@@ -0,0 +1,277 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, get_command_handler::SonarrGetCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_get_command_from() {
+    let command = SonarrGetCommand::SystemStatus;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::Get(command)));
+  }
+
+  mod cli {
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_all_indexer_settings_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "all-indexer-settings"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_system_status_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "system-status"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_episode_details_requires_episode_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "episode-details"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_episode_details_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "get",
+        "episode-details",
+        "--episode-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_get_host_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "host-config"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_get_security_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "security-config"]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_series_details_requires_series_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "get", "series-details"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_series_details_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "get",
+        "series-details",
+        "--series-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,
+        sonarr::get_command_handler::{SonarrGetCommand, SonarrGetCommandHandler},
+      },
+      models::{Serdeable, sonarr_models::SonarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[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>(
+          SonarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_all_indexer_settings_command = SonarrGetCommand::AllIndexerSettings;
+
+      let result = SonarrGetCommandHandler::with(
+        &app_arc,
+        get_all_indexer_settings_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_episode_details_command() {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodeDetails(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_episode_details_command = SonarrGetCommand::EpisodeDetails { episode_id: 1 };
+
+      let result =
+        SonarrGetCommandHandler::with(&app_arc, get_episode_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>(SonarrEvent::GetHostConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_host_config_command = SonarrGetCommand::HostConfig;
+
+      let result =
+        SonarrGetCommandHandler::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>(SonarrEvent::GetSecurityConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_security_config_command = SonarrGetCommand::SecurityConfig;
+
+      let result =
+        SonarrGetCommandHandler::with(&app_arc, get_security_config_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_get_series_details_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetSeriesDetails(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_series_details_command = SonarrGetCommand::SeriesDetails { series_id: 1 };
+
+      let result =
+        SonarrGetCommandHandler::with(&app_arc, get_series_details_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>(SonarrEvent::GetStatus.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_system_status_command = SonarrGetCommand::SystemStatus;
+
+      let result =
+        SonarrGetCommandHandler::with(&app_arc, get_system_status_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/list_command_handler.rs

@@ -0,0 +1,295 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "list_command_handler_tests.rs"]
+mod list_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrListCommand {
+  #[command(about = "List all items in the Sonarr blocklist")]
+  Blocklist,
+  #[command(about = "List all active downloads in Sonarr")]
+  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 Sonarr")]
+  DiskSpace,
+  #[command(about = "List the episodes for the series with the given ID")]
+  Episodes {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose episodes you wish to fetch",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(about = "List the episode files for the series with the given ID")]
+  EpisodeFiles {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose episode files you wish to fetch",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(about = "Fetch all history events for the episode with the given ID")]
+  EpisodeHistory {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the episode whose history you wish to fetch",
+      required = true
+    )]
+    episode_id: i64,
+  },
+  #[command(about = "Fetch all Sonarr history events")]
+  History {
+    #[arg(long, help = "How many history events to fetch", default_value_t = 500)]
+    events: u64,
+  },
+  #[command(about = "List all Sonarr indexers")]
+  Indexers,
+  #[command(about = "List all Sonarr language profiles")]
+  LanguageProfiles,
+  #[command(about = "Fetch Sonarr 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 Sonarr quality profiles")]
+  QualityProfiles,
+  #[command(about = "List all queued events")]
+  QueuedEvents,
+  #[command(about = "List all root folders in Sonarr")]
+  RootFolders,
+  #[command(
+    about = "Fetch all history events for the given season corresponding to the series with the given ID."
+  )]
+  SeasonHistory {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose history you wish to fetch and list",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(
+      long,
+      help = "The season number to fetch history events for",
+      required = true
+    )]
+    season_number: i64,
+  },
+  #[command(about = "List all series in your Sonarr library")]
+  Series,
+  #[command(about = "Fetch all history events for the series with the given ID")]
+  SeriesHistory {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose history you wish to fetch",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(about = "List all Sonarr tags")]
+  Tags,
+  #[command(about = "List all Sonarr tasks")]
+  Tasks,
+  #[command(about = "List all Sonarr updates")]
+  Updates,
+}
+
+impl From<SonarrListCommand> for Command {
+  fn from(value: SonarrListCommand) -> Self {
+    Command::Sonarr(SonarrCommand::List(value))
+  }
+}
+
+pub(super) struct SonarrListCommandHandler<'a, 'b> {
+  app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrListCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrListCommand> for SonarrListCommandHandler<'a, 'b> {
+  fn with(
+    app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrListCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrListCommandHandler {
+      app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrListCommand::Blocklist => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Downloads { count } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetDownloads(count).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::DiskSpace => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetDiskSpace.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Episodes { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetEpisodes(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::EpisodeFiles { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetEpisodeFiles(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::EpisodeHistory { episode_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetEpisodeHistory(episode_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::History { events: items } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetHistory(items).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Indexers => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetIndexers.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::LanguageProfiles => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetLanguageProfiles.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Logs {
+        events,
+        output_in_log_format,
+      } => {
+        let logs = self
+          .network
+          .handle_network_event(SonarrEvent::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)?
+        }
+      }
+      SonarrListCommand::QualityProfiles => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetQualityProfiles.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::QueuedEvents => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetQueuedEvents.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::RootFolders => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetRootFolders.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::SeasonHistory {
+        series_id,
+        season_number,
+      } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetSeasonHistory((series_id, season_number)).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Series => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::ListSeries.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::SeriesHistory { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetSeriesHistory(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Tags => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetTags.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Tasks => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetTasks.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrListCommand::Updates => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetUpdates.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/list_command_handler_tests.rs

@@ -0,0 +1,568 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, list_command_handler::SonarrListCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_list_command_from() {
+    let command = SonarrListCommand::Series;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::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(
+        "blocklist",
+        "series",
+        "disk-space",
+        "quality-profiles",
+        "indexers",
+        "queued-events",
+        "root-folders",
+        "tags",
+        "tasks",
+        "updates",
+        "language-profiles"
+      )]
+      subcommand: &str,
+    ) {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "list", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_list_episodes_requires_series_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "episodes"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_episode_files_requires_series_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "episode-files"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_episode_history_requires_series_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "episode-history"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_episode_history_success() {
+      let expected_args = SonarrListCommand::EpisodeHistory { episode_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "episode-history",
+        "--episode-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::List(episode_history_command))) =
+        result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(episode_history_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_downloads_count_flag_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "downloads", "--count"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_downloads_default_values() {
+      let expected_args = SonarrListCommand::Downloads { count: 500 };
+      let result = Cli::try_parse_from(["managarr", "sonarr", "list", "downloads"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "list", "history", "--events"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_history_default_values() {
+      let expected_args = SonarrListCommand::History { events: 500 };
+      let result = Cli::try_parse_from(["managarr", "sonarr", "list", "history"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::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", "sonarr", "list", "logs", "--events"]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn test_list_logs_default_values() {
+      let expected_args = SonarrListCommand::Logs {
+        events: 500,
+        output_in_log_format: false,
+      };
+      let result = Cli::try_parse_from(["managarr", "sonarr", "list", "logs"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::List(logs_command))) = result.unwrap().command else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(logs_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_episodes_success() {
+      let expected_args = SonarrListCommand::Episodes { series_id: 1 };
+      let result =
+        Cli::try_parse_from(["managarr", "sonarr", "list", "episodes", "--series-id", "1"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::List(episodes_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(episodes_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_episode_files_success() {
+      let expected_args = SonarrListCommand::EpisodeFiles { series_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "episode-files",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::List(episode_files_command))) =
+        result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(episode_files_command, expected_args);
+    }
+
+    #[test]
+    fn test_season_history_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "season-history",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_season_history_requires_season_number() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "season-history",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_season_history_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "season-history",
+        "--series-id",
+        "1",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_list_series_history_requires_series_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "list", "series-history"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_list_series_history_success() {
+      let expected_args = SonarrListCommand::SeriesHistory { series_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "list",
+        "series-history",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::List(series_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(series_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::cli::CliCommandHandler;
+    use crate::cli::sonarr::list_command_handler::{SonarrListCommand, SonarrListCommandHandler};
+    use crate::models::Serdeable;
+    use crate::models::sonarr_models::SonarrSerdeable;
+    use crate::network::sonarr_network::SonarrEvent;
+    use crate::{
+      app::App,
+      network::{MockNetworkTrait, NetworkEvent},
+    };
+
+    #[rstest]
+    #[case(SonarrListCommand::Blocklist, SonarrEvent::GetBlocklist)]
+    #[case(SonarrListCommand::DiskSpace, SonarrEvent::GetDiskSpace)]
+    #[case(SonarrListCommand::Indexers, SonarrEvent::GetIndexers)]
+    #[case(SonarrListCommand::QualityProfiles, SonarrEvent::GetQualityProfiles)]
+    #[case(SonarrListCommand::QueuedEvents, SonarrEvent::GetQueuedEvents)]
+    #[case(SonarrListCommand::RootFolders, SonarrEvent::GetRootFolders)]
+    #[case(SonarrListCommand::Series, SonarrEvent::ListSeries)]
+    #[case(SonarrListCommand::Tags, SonarrEvent::GetTags)]
+    #[case(SonarrListCommand::Tasks, SonarrEvent::GetTasks)]
+    #[case(SonarrListCommand::Updates, SonarrEvent::GetUpdates)]
+    #[case(SonarrListCommand::LanguageProfiles, SonarrEvent::GetLanguageProfiles)]
+    #[tokio::test]
+    async fn test_handle_list_command(
+      #[case] list_command: SonarrListCommand,
+      #[case] expected_sonarr_event: SonarrEvent,
+    ) {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(expected_sonarr_event.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+
+      let result = SonarrListCommandHandler::with(&app_arc, list_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_episodes_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodes(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_episodes_command = SonarrListCommand::Episodes { series_id: 1 };
+
+      let result =
+        SonarrListCommandHandler::with(&app_arc, list_episodes_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_episode_files_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodeFiles(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_episode_files_command = SonarrListCommand::EpisodeFiles { series_id: 1 };
+
+      let result =
+        SonarrListCommandHandler::with(&app_arc, list_episode_files_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>(
+          SonarrEvent::GetDownloads(expected_count).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_downloads_command = SonarrListCommand::Downloads { count: 1000 };
+
+      let result =
+        SonarrListCommandHandler::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>(
+          SonarrEvent::GetHistory(expected_events).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_history_command = SonarrListCommand::History { events: 1000 };
+
+      let result =
+        SonarrListCommandHandler::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>(
+          SonarrEvent::GetLogs(expected_events).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_logs_command = SonarrListCommand::Logs {
+        events: 1000,
+        output_in_log_format: false,
+      };
+
+      let result = SonarrListCommandHandler::with(&app_arc, list_logs_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_series_history_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetSeriesHistory(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_series_history_command = SonarrListCommand::SeriesHistory { series_id: 1 };
+
+      let result =
+        SonarrListCommandHandler::with(&app_arc, list_series_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_list_episode_history_command() {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodeHistory(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_episode_history_command = SonarrListCommand::EpisodeHistory { episode_id: 1 };
+
+      let result =
+        SonarrListCommandHandler::with(&app_arc, list_episode_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_list_season_history_command() {
+      let expected_series_id = 1;
+      let expected_season_number = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetSeasonHistory((expected_series_id, expected_season_number)).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_season_history_command = SonarrListCommand::SeasonHistory {
+        series_id: 1,
+        season_number: 1,
+      };
+
+      let result =
+        SonarrListCommandHandler::with(&app_arc, list_season_history_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/manual_search_command_handler.rs

@@ -0,0 +1,97 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[cfg(test)]
+#[path = "manual_search_command_handler_tests.rs"]
+mod manual_search_command_handler_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrManualSearchCommand {
+  #[command(about = "Trigger a manual search of releases for the episode with the given ID")]
+  Episode {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the episode whose releases you wish to fetch and list",
+      required = true
+    )]
+    episode_id: i64,
+  },
+  #[command(
+    about = "Trigger a manual search of releases for the given season corresponding to the series with the given ID.\nNote that when downloading a season release, ensure that the release includes 'fullSeason: true', otherwise you'll run into issues"
+  )]
+  Season {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose releases you wish to fetch and list",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(long, help = "The season number to search for", required = true)]
+    season_number: i64,
+  },
+}
+
+impl From<SonarrManualSearchCommand> for Command {
+  fn from(value: SonarrManualSearchCommand) -> Self {
+    Command::Sonarr(SonarrCommand::ManualSearch(value))
+  }
+}
+
+pub(super) struct SonarrManualSearchCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrManualSearchCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrManualSearchCommand>
+  for SonarrManualSearchCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrManualSearchCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrManualSearchCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrManualSearchCommand::Episode { episode_id } => {
+        println!("Searching for episode releases. This may take a minute...");
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetEpisodeReleases(episode_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrManualSearchCommand::Season {
+        series_id,
+        season_number,
+      } => {
+        println!("Searching for season releases. This may take a minute...");
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::GetSeasonReleases((series_id, season_number)).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/manual_search_command_handler_tests.rs

@@ -0,0 +1,188 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, manual_search_command_handler::SonarrManualSearchCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_manual_search_command_from() {
+    let command = SonarrManualSearchCommand::Episode { episode_id: 1 };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(
+      result,
+      Command::Sonarr(SonarrCommand::ManualSearch(command))
+    );
+  }
+
+  mod cli {
+    use super::*;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_manual_season_search_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "manual-search",
+        "season",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_season_search_requires_season_number() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "manual-search",
+        "season",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_season_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "manual-search",
+        "season",
+        "--series-id",
+        "1",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_manual_episode_search_requires_episode_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "manual-search", "episode"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_manual_episode_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "manual-search",
+        "episode",
+        "--episode-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,
+        sonarr::manual_search_command_handler::{
+          SonarrManualSearchCommand, SonarrManualSearchCommandHandler,
+        },
+      },
+      models::{Serdeable, sonarr_models::SonarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_manual_episode_search_command() {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodeReleases(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_episode_search_command = SonarrManualSearchCommand::Episode { episode_id: 1 };
+
+      let result = SonarrManualSearchCommandHandler::with(
+        &app_arc,
+        manual_episode_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_manual_season_search_command() {
+      let expected_series_id = 1;
+      let expected_season_number = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetSeasonReleases((expected_series_id, expected_season_number)).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_season_search_command = SonarrManualSearchCommand::Season {
+        series_id: 1,
+        season_number: 1,
+      };
+
+      let result = SonarrManualSearchCommandHandler::with(
+        &app_arc,
+        manual_season_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/mod.rs

@@ -0,0 +1,315 @@
+use std::sync::Arc;
+
+use add_command_handler::{SonarrAddCommand, SonarrAddCommandHandler};
+use anyhow::Result;
+use clap::Subcommand;
+use delete_command_handler::{SonarrDeleteCommand, SonarrDeleteCommandHandler};
+use download_command_handler::{SonarrDownloadCommand, SonarrDownloadCommandHandler};
+use edit_command_handler::{SonarrEditCommand, SonarrEditCommandHandler};
+use get_command_handler::{SonarrGetCommand, SonarrGetCommandHandler};
+use list_command_handler::{SonarrListCommand, SonarrListCommandHandler};
+use manual_search_command_handler::{SonarrManualSearchCommand, SonarrManualSearchCommandHandler};
+use refresh_command_handler::{SonarrRefreshCommand, SonarrRefreshCommandHandler};
+use tokio::sync::Mutex;
+use trigger_automatic_search_command_handler::{
+  SonarrTriggerAutomaticSearchCommand, SonarrTriggerAutomaticSearchCommandHandler,
+};
+
+use crate::{
+  app::App,
+  models::sonarr_models::SonarrTaskName,
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::{CliCommandHandler, Command};
+
+mod add_command_handler;
+mod delete_command_handler;
+mod download_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 = "sonarr_command_tests.rs"]
+mod sonarr_command_tests;
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum SonarrCommand {
+  #[command(
+    subcommand,
+    about = "Commands to add or create new resources within your Sonarr instance"
+  )]
+  Add(SonarrAddCommand),
+  #[command(
+    subcommand,
+    about = "Commands to delete resources from your Sonarr instance"
+  )]
+  Delete(SonarrDeleteCommand),
+  #[command(
+    subcommand,
+    about = "Commands to edit resources in your Sonarr instance"
+  )]
+  Edit(SonarrEditCommand),
+  #[command(
+    subcommand,
+    about = "Commands to fetch details of the resources in your Sonarr instance"
+  )]
+  Get(SonarrGetCommand),
+  #[command(
+    subcommand,
+    about = "Commands to download releases in your Sonarr instance"
+  )]
+  Download(SonarrDownloadCommand),
+  #[command(
+    subcommand,
+    about = "Commands to list attributes from your Sonarr instance"
+  )]
+  List(SonarrListCommand),
+  #[command(
+    subcommand,
+    about = "Commands to refresh the data in your Sonarr instance"
+  )]
+  Refresh(SonarrRefreshCommand),
+  #[command(subcommand, about = "Commands to manually search for releases")]
+  ManualSearch(SonarrManualSearchCommand),
+  #[command(
+    subcommand,
+    about = "Commands to trigger automatic searches for releases of different resources in your Sonarr instance"
+  )]
+  TriggerAutomaticSearch(SonarrTriggerAutomaticSearchCommand),
+  #[command(about = "Clear the blocklist")]
+  ClearBlocklist,
+  #[command(about = "Mark the Sonarr history item with the given ID as 'failed'")]
+  MarkHistoryItemAsFailed {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the history item you wish to mark as 'failed'",
+      required = true
+    )]
+    history_item_id: i64,
+  },
+  #[command(about = "Search for a new series to add to Sonarr")]
+  SearchNewSeries {
+    #[arg(
+      long,
+      help = "The title of the series you want to search for",
+      required = true
+    )]
+    query: String,
+  },
+  #[command(about = "Start the specified Sonarr task")]
+  StartTask {
+    #[arg(
+      long,
+      help = "The name of the task to trigger",
+      value_enum,
+      required = true
+    )]
+    task_name: SonarrTaskName,
+  },
+  #[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 Sonarr indexers")]
+  TestAllIndexers,
+  #[command(about = "Toggle monitoring for the specified episode")]
+  ToggleEpisodeMonitoring {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the episode to toggle monitoring on",
+      required = true
+    )]
+    episode_id: i64,
+  },
+  #[command(
+    about = "Toggle monitoring for the specified season that corresponds to the specified series ID"
+  )]
+  ToggleSeasonMonitoring {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series that the season belongs to",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(
+      long,
+      help = "The season number to toggle monitoring for",
+      required = true
+    )]
+    season_number: i64,
+  },
+  #[command(
+    about = "Toggle monitoring for the specified series corresponding to the given series ID"
+  )]
+  ToggleSeriesMonitoring {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series to toggle monitoring on",
+      required = true
+    )]
+    series_id: i64,
+  },
+}
+
+impl From<SonarrCommand> for Command {
+  fn from(sonarr_command: SonarrCommand) -> Command {
+    Command::Sonarr(sonarr_command)
+  }
+}
+
+pub(super) struct SonarrCliHandler<'a, 'b> {
+  app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrCommand> for SonarrCliHandler<'a, 'b> {
+  fn with(
+    app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrCliHandler {
+      app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrCommand::Add(add_command) => {
+        SonarrAddCommandHandler::with(self.app, add_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::Delete(delete_command) => {
+        SonarrDeleteCommandHandler::with(self.app, delete_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::Edit(edit_command) => {
+        SonarrEditCommandHandler::with(self.app, edit_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::Download(download_command) => {
+        SonarrDownloadCommandHandler::with(self.app, download_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::Get(get_command) => {
+        SonarrGetCommandHandler::with(self.app, get_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::List(list_command) => {
+        SonarrListCommandHandler::with(self.app, list_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::Refresh(refresh_command) => {
+        SonarrRefreshCommandHandler::with(self.app, refresh_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::ManualSearch(manual_search_command) => {
+        SonarrManualSearchCommandHandler::with(self.app, manual_search_command, self.network)
+          .handle()
+          .await?
+      }
+      SonarrCommand::TriggerAutomaticSearch(trigger_automatic_search_command) => {
+        SonarrTriggerAutomaticSearchCommandHandler::with(
+          self.app,
+          trigger_automatic_search_command,
+          self.network,
+        )
+        .handle()
+        .await?
+      }
+      SonarrCommand::ClearBlocklist => {
+        self
+          .network
+          .handle_network_event(SonarrEvent::GetBlocklist.into())
+          .await?;
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::ClearBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::MarkHistoryItemAsFailed { history_item_id } => {
+        let _ = self
+          .network
+          .handle_network_event(SonarrEvent::MarkHistoryItemAsFailed(history_item_id).into())
+          .await?;
+        "Sonarr history item marked as 'failed'".to_owned()
+      }
+      SonarrCommand::SearchNewSeries { query } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::SearchNewSeries(query).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::StartTask { task_name } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::StartTask(task_name).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::TestIndexer { indexer_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::TestIndexer(indexer_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::TestAllIndexers => {
+        println!("Testing all Sonarr indexers. This may take a minute...");
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::TestAllIndexers.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::ToggleEpisodeMonitoring { episode_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::ToggleEpisodeMonitoring(episode_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::ToggleSeasonMonitoring {
+        series_id,
+        season_number,
+      } => {
+        let resp = self
+          .network
+          .handle_network_event(
+            SonarrEvent::ToggleSeasonMonitoring((series_id, season_number)).into(),
+          )
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrCommand::ToggleSeriesMonitoring { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::ToggleSeriesMonitoring(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/refresh_command_handler.rs

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

src/cli/sonarr/refresh_command_handler_tests.rs

@@ -0,0 +1,141 @@
+#[cfg(test)]
+mod tests {
+  use pretty_assertions::assert_eq;
+
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, refresh_command_handler::SonarrRefreshCommand},
+  };
+  use clap::CommandFactory;
+
+  #[test]
+  fn test_sonarr_refresh_command_from() {
+    let command = SonarrRefreshCommand::AllSeries;
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(SonarrCommand::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-series", "downloads")] subcommand: &str,
+    ) {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "refresh", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_refresh_series_requires_series_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "refresh", "series"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_refresh_series_success() {
+      let expected_args = SonarrRefreshCommand::Series { series_id: 1 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "sonarr",
+        "refresh",
+        "series",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Sonarr(SonarrCommand::Refresh(refresh_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(refresh_command, expected_args);
+    }
+  }
+
+  mod handler {
+    use rstest::rstest;
+    use std::sync::Arc;
+
+    use mockall::predicate::eq;
+    use serde_json::json;
+    use tokio::sync::Mutex;
+
+    use crate::{app::App, cli::sonarr::refresh_command_handler::SonarrRefreshCommandHandler};
+    use crate::{
+      cli::{CliCommandHandler, sonarr::refresh_command_handler::SonarrRefreshCommand},
+      network::sonarr_network::SonarrEvent,
+    };
+    use crate::{
+      models::{Serdeable, sonarr_models::SonarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent},
+    };
+
+    #[rstest]
+    #[case(SonarrRefreshCommand::AllSeries, SonarrEvent::UpdateAllSeries)]
+    #[case(SonarrRefreshCommand::Downloads, SonarrEvent::UpdateDownloads)]
+    #[tokio::test]
+    async fn test_handle_refresh_command(
+      #[case] refresh_command: SonarrRefreshCommand,
+      #[case] expected_sonarr_event: SonarrEvent,
+    ) {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(expected_sonarr_event.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+
+      let result = SonarrRefreshCommandHandler::with(&app_arc, refresh_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_handle_refresh_series_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::UpdateAndScanSeries(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let refresh_series_command = SonarrRefreshCommand::Series { series_id: 1 };
+
+      let result =
+        SonarrRefreshCommandHandler::with(&app_arc, refresh_series_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/sonarr_command_tests.rs

@@ -0,0 +1,811 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{SonarrCommand, list_command_handler::SonarrListCommand},
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_command_from() {
+    let command = SonarrCommand::List(SonarrListCommand::Series);
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(result, Command::Sonarr(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", "sonarr", subcommand]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_mark_history_item_as_failed_requires_history_item_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "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",
+        "sonarr",
+        "mark-history-item-as-failed",
+        "--history-item-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_search_new_series_requires_query() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "search-new-series"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_search_new_series_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "search-new-series",
+        "--query",
+        "halo",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_start_task_requires_task_name() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "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",
+        "sonarr",
+        "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",
+        "sonarr",
+        "start-task",
+        "--task-name",
+        "application-update-check",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_test_indexer_requires_indexer_id() {
+      let result = Cli::command().try_get_matches_from(["managarr", "sonarr", "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",
+        "sonarr",
+        "test-indexer",
+        "--indexer-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_toggle_episode_monitoring_requires_episode_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "toggle-episode-monitoring"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_episode_monitoring_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "toggle-episode-monitoring",
+        "--episode-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_toggle_season_monitoring_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "toggle-season-monitoring",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_season_monitoring_requires_season_number() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "toggle-season-monitoring",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_season_monitoring_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "toggle-season-monitoring",
+        "--series-id",
+        "1",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_toggle_series_monitoring_requires_series_id() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "sonarr", "toggle-series-monitoring"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_toggle_series_monitoring_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "toggle-series-monitoring",
+        "--series-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,
+        sonarr::{
+          SonarrCliHandler, SonarrCommand, add_command_handler::SonarrAddCommand,
+          delete_command_handler::SonarrDeleteCommand,
+          download_command_handler::SonarrDownloadCommand, edit_command_handler::SonarrEditCommand,
+          get_command_handler::SonarrGetCommand, list_command_handler::SonarrListCommand,
+          manual_search_command_handler::SonarrManualSearchCommand,
+          refresh_command_handler::SonarrRefreshCommand,
+          trigger_automatic_search_command_handler::SonarrTriggerAutomaticSearchCommand,
+        },
+      },
+      models::{
+        Serdeable,
+        sonarr_models::{
+          BlocklistItem, BlocklistResponse, IndexerSettings, Series, SonarrReleaseDownloadBody,
+          SonarrSerdeable, SonarrTaskName,
+        },
+      },
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_handle_clear_blocklist_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(SonarrEvent::GetBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::BlocklistResponse(
+            BlocklistResponse {
+              records: vec![BlocklistItem::default()],
+            },
+          )))
+        });
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(SonarrEvent::ClearBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let claer_blocklist_command = SonarrCommand::ClearBlocklist;
+
+      let result = SonarrCliHandler::with(&app_arc, claer_blocklist_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 = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::MarkHistoryItemAsFailed(expected_history_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let mark_history_item_as_failed_command =
+        SonarrCommand::MarkHistoryItemAsFailed { history_item_id: 1 };
+
+      let result = SonarrCliHandler::with(
+        &app_arc,
+        mark_history_item_as_failed_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_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>(
+          SonarrEvent::AddTag(expected_tag_name.clone()).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let add_tag_command = SonarrCommand::Add(SonarrAddCommand::Tag {
+        name: expected_tag_name,
+      });
+
+      let result = SonarrCliHandler::with(&app_arc, add_tag_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_cli_handler_delegates_delete_commands_to_the_delete_command_handler() {
+      let expected_blocklist_item_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_blocklist_item_command =
+        SonarrCommand::Delete(SonarrDeleteCommand::BlocklistItem {
+          blocklist_item_id: 1,
+        });
+
+      let result =
+        SonarrCliHandler::with(&app_arc, delete_blocklist_item_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_cli_handler_delegates_download_commands_to_the_download_command_handler() {
+      let expected_params = SonarrReleaseDownloadBody {
+        guid: "1234".to_owned(),
+        indexer_id: 1,
+        series_id: Some(1),
+        ..SonarrReleaseDownloadBody::default()
+      };
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::DownloadRelease(expected_params).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let download_series_release_command =
+        SonarrCommand::Download(SonarrDownloadCommand::Series {
+          guid: "1234".to_owned(),
+          indexer_id: 1,
+          series_id: 1,
+        });
+
+      let result =
+        SonarrCliHandler::with(&app_arc, download_series_release_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_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>(
+          SonarrEvent::GetAllIndexerSettings.into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::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>(
+          SonarrEvent::EditAllIndexerSettings(expected_edit_all_indexer_settings).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let edit_all_indexer_settings_command =
+        SonarrCommand::Edit(SonarrEditCommand::AllIndexerSettings {
+          maximum_size: Some(1),
+          minimum_age: Some(1),
+          retention: Some(1),
+          rss_sync_interval: Some(1),
+        });
+
+      let result = SonarrCliHandler::with(
+        &app_arc,
+        edit_all_indexer_settings_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_cli_handler_delegates_manual_search_commands_to_the_manual_search_command_handler()
+     {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::GetEpisodeReleases(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_episode_search_command =
+        SonarrCommand::ManualSearch(SonarrManualSearchCommand::Episode { episode_id: 1 });
+
+      let result =
+        SonarrCliHandler::with(&app_arc, manual_episode_search_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_cli_handler_delegates_trigger_automatic_search_commands_to_the_trigger_automatic_search_command_handler()
+     {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::TriggerAutomaticEpisodeSearch(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let manual_episode_search_command =
+        SonarrCommand::TriggerAutomaticSearch(SonarrTriggerAutomaticSearchCommand::Episode {
+          episode_id: 1,
+        });
+
+      let result =
+        SonarrCliHandler::with(&app_arc, manual_episode_search_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_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>(SonarrEvent::GetStatus.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let get_system_status_command = SonarrCommand::Get(SonarrGetCommand::SystemStatus);
+
+      let result = SonarrCliHandler::with(&app_arc, get_system_status_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_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>(SonarrEvent::ListSeries.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::SeriesVec(vec![
+            Series::default(),
+          ])))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_series_command = SonarrCommand::List(SonarrListCommand::Series);
+
+      let result = SonarrCliHandler::with(&app_arc, list_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_cli_handler_delegates_refresh_commands_to_the_refresh_command_handler() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::UpdateAndScanSeries(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let refresh_series_command =
+        SonarrCommand::Refresh(SonarrRefreshCommand::Series { series_id: 1 });
+
+      let result = SonarrCliHandler::with(&app_arc, refresh_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_search_new_series_command() {
+      let expected_search_query = "halo".to_owned();
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::SearchNewSeries(expected_search_query).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let search_new_series_command = SonarrCommand::SearchNewSeries {
+        query: "halo".to_owned(),
+      };
+
+      let result = SonarrCliHandler::with(&app_arc, search_new_series_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_start_task_command() {
+      let expected_task_name = SonarrTaskName::ApplicationUpdateCheck;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::StartTask(expected_task_name).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let start_task_command = SonarrCommand::StartTask {
+        task_name: SonarrTaskName::ApplicationUpdateCheck,
+      };
+
+      let result = SonarrCliHandler::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>(
+          SonarrEvent::TestIndexer(expected_indexer_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let test_indexer_command = SonarrCommand::TestIndexer { indexer_id: 1 };
+
+      let result = SonarrCliHandler::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>(SonarrEvent::TestAllIndexers.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let test_all_indexers_command = SonarrCommand::TestAllIndexers;
+
+      let result = SonarrCliHandler::with(&app_arc, test_all_indexers_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_toggle_episode_monitoring_command() {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::ToggleEpisodeMonitoring(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let toggle_episode_monitoring_command =
+        SonarrCommand::ToggleEpisodeMonitoring { episode_id: 1 };
+
+      let result = SonarrCliHandler::with(
+        &app_arc,
+        toggle_episode_monitoring_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_toggle_season_monitoring_command() {
+      let expected_series_id = 1;
+      let expected_season_number = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::ToggleSeasonMonitoring((expected_series_id, expected_season_number)).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let toggle_season_monitoring_command = SonarrCommand::ToggleSeasonMonitoring {
+        series_id: 1,
+        season_number: 1,
+      };
+
+      let result = SonarrCliHandler::with(
+        &app_arc,
+        toggle_season_monitoring_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_toggle_series_monitoring_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::ToggleSeriesMonitoring(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let toggle_series_monitoring_command = SonarrCommand::ToggleSeriesMonitoring { series_id: 1 };
+
+      let result = SonarrCliHandler::with(
+        &app_arc,
+        toggle_series_monitoring_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/cli/sonarr/trigger_automatic_search_command_handler.rs

@@ -0,0 +1,113 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Subcommand;
+use tokio::sync::Mutex;
+
+use crate::{
+  app::App,
+  cli::{CliCommandHandler, Command},
+  network::{NetworkTrait, sonarr_network::SonarrEvent},
+};
+
+use super::SonarrCommand;
+
+#[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 SonarrTriggerAutomaticSearchCommand {
+  #[command(about = "Trigger an automatic search for the series with the specified ID")]
+  Series {
+    #[arg(
+      long,
+      help = "The ID of the series you want to trigger an automatic search for",
+      required = true
+    )]
+    series_id: i64,
+  },
+  #[command(
+    about = "Trigger an automatic search for the given season corresponding to the series with the given ID"
+  )]
+  Season {
+    #[arg(
+      long,
+      help = "The Sonarr ID of the series whose season you wish to trigger an automatic search for",
+      required = true
+    )]
+    series_id: i64,
+    #[arg(long, help = "The season number to search for", required = true)]
+    season_number: i64,
+  },
+  #[command(about = "Trigger an automatic search for the episode with the specified ID")]
+  Episode {
+    #[arg(
+      long,
+      help = "The ID of the episode you want to trigger an automatic search for",
+      required = true
+    )]
+    episode_id: i64,
+  },
+}
+
+impl From<SonarrTriggerAutomaticSearchCommand> for Command {
+  fn from(value: SonarrTriggerAutomaticSearchCommand) -> Self {
+    Command::Sonarr(SonarrCommand::TriggerAutomaticSearch(value))
+  }
+}
+
+pub(super) struct SonarrTriggerAutomaticSearchCommandHandler<'a, 'b> {
+  _app: &'a Arc<Mutex<App<'b>>>,
+  command: SonarrTriggerAutomaticSearchCommand,
+  network: &'a mut dyn NetworkTrait,
+}
+
+impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrTriggerAutomaticSearchCommand>
+  for SonarrTriggerAutomaticSearchCommandHandler<'a, 'b>
+{
+  fn with(
+    _app: &'a Arc<Mutex<App<'b>>>,
+    command: SonarrTriggerAutomaticSearchCommand,
+    network: &'a mut dyn NetworkTrait,
+  ) -> Self {
+    SonarrTriggerAutomaticSearchCommandHandler {
+      _app,
+      command,
+      network,
+    }
+  }
+
+  async fn handle(self) -> Result<String> {
+    let result = match self.command {
+      SonarrTriggerAutomaticSearchCommand::Series { series_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::TriggerAutomaticSeriesSearch(series_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrTriggerAutomaticSearchCommand::Season {
+        series_id,
+        season_number,
+      } => {
+        let resp = self
+          .network
+          .handle_network_event(
+            SonarrEvent::TriggerAutomaticSeasonSearch((series_id, season_number)).into(),
+          )
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+      SonarrTriggerAutomaticSearchCommand::Episode { episode_id } => {
+        let resp = self
+          .network
+          .handle_network_event(SonarrEvent::TriggerAutomaticEpisodeSearch(episode_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
+    };
+
+    Ok(result)
+  }
+}

src/cli/sonarr/trigger_automatic_search_command_handler_tests.rs

@@ -0,0 +1,256 @@
+#[cfg(test)]
+mod tests {
+  use crate::Cli;
+  use crate::cli::{
+    Command,
+    sonarr::{
+      SonarrCommand, trigger_automatic_search_command_handler::SonarrTriggerAutomaticSearchCommand,
+    },
+  };
+  use clap::CommandFactory;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_sonarr_trigger_automatic_search_command_from() {
+    let command = SonarrTriggerAutomaticSearchCommand::Episode { episode_id: 1 };
+
+    let result = Command::from(command.clone());
+
+    assert_eq!(
+      result,
+      Command::Sonarr(SonarrCommand::TriggerAutomaticSearch(command))
+    );
+  }
+
+  mod cli {
+    use super::*;
+    use clap::error::ErrorKind;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_trigger_automatic_series_search_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "series",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_series_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "series",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_trigger_automatic_season_search_requires_series_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "season",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_season_search_requires_season_number() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "season",
+        "--series-id",
+        "1",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_season_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "season",
+        "--series-id",
+        "1",
+        "--season-number",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+    }
+
+    #[test]
+    fn test_trigger_automatic_episode_search_requires_episode_id() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "episode",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_trigger_automatic_episode_search_requirements_satisfied() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "sonarr",
+        "trigger-automatic-search",
+        "episode",
+        "--episode-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,
+        sonarr::trigger_automatic_search_command_handler::{
+          SonarrTriggerAutomaticSearchCommand, SonarrTriggerAutomaticSearchCommandHandler,
+        },
+      },
+      models::{Serdeable, sonarr_models::SonarrSerdeable},
+      network::{MockNetworkTrait, NetworkEvent, sonarr_network::SonarrEvent},
+    };
+
+    #[tokio::test]
+    async fn test_trigger_automatic_series_search_command() {
+      let expected_series_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::TriggerAutomaticSeriesSearch(expected_series_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_series_search_command =
+        SonarrTriggerAutomaticSearchCommand::Series { series_id: 1 };
+
+      let result = SonarrTriggerAutomaticSearchCommandHandler::with(
+        &app_arc,
+        trigger_automatic_series_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_trigger_automatic_season_search_command() {
+      let expected_series_id = 1;
+      let expected_season_number = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::TriggerAutomaticSeasonSearch((expected_series_id, expected_season_number))
+            .into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_season_search_command = SonarrTriggerAutomaticSearchCommand::Season {
+        series_id: 1,
+        season_number: 1,
+      };
+
+      let result = SonarrTriggerAutomaticSearchCommandHandler::with(
+        &app_arc,
+        trigger_automatic_season_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
+    #[tokio::test]
+    async fn test_trigger_automatic_episode_search_command() {
+      let expected_episode_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          SonarrEvent::TriggerAutomaticEpisodeSearch(expected_episode_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Sonarr(SonarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let trigger_automatic_episode_search_command =
+        SonarrTriggerAutomaticSearchCommand::Episode { episode_id: 1 };
+
+      let result = SonarrTriggerAutomaticSearchCommandHandler::with(
+        &app_arc,
+        trigger_automatic_episode_search_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+  }
+}

src/event/input_event.rs

@@ -4,7 +4,7 @@ use std::thread;
 use std::time::{Duration, Instant};
 
 use crossterm::event;
-use crossterm::event::Event as CrosstermEvent;
+use crossterm::event::{Event as CrosstermEvent, KeyEventKind};
 
 use crate::event::Key;
 
@@ -28,8 +28,12 @@ impl Events {
         let timeout = tick_rate
           .checked_sub(last_tick.elapsed())
           .unwrap_or_else(|| Duration::from_secs(0));
-        if event::poll(timeout).unwrap() {
-          if let CrosstermEvent::Key(key_event) = event::read().unwrap() {
+        if event::poll(timeout).unwrap()
+          && let CrosstermEvent::Key(key_event) = event::read().unwrap()
+        {
+          // Only process the key event if it's a press event
+          // Source: https://ratatui.rs/faq/ Why am I getting duplicate key events on Windows?
+          if key_event.kind == KeyEventKind::Press {
             let key = Key::from(key_event);
             tx.send(InputEvent::KeyEvent(key)).unwrap();
           }

src/event/key.rs

@@ -13,12 +13,15 @@ pub enum Key {
   Down,
   Left,
   Right,
+  PgDown,
+  PgUp,
   Enter,
   Esc,
   Backspace,
   Home,
   End,
   Tab,
+  BackTab,
   Delete,
   Ctrl(char),
   Char(char),
@@ -28,20 +31,23 @@ pub enum Key {
 impl Display for Key {
   fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
     match *self {
-      Key::Char(c) => write!(f, "<{c}>"),
-      Key::Ctrl(c) => write!(f, "<ctrl-{c}>"),
-      Key::Up => write!(f, "<↑>"),
-      Key::Down => write!(f, "<↓>"),
-      Key::Left => write!(f, "<←>"),
-      Key::Right => write!(f, "<→>"),
-      Key::Enter => write!(f, "<enter>"),
-      Key::Esc => write!(f, "<esc>"),
-      Key::Backspace => write!(f, "<backspace>"),
-      Key::Home => write!(f, "<home>"),
-      Key::End => write!(f, "<end>"),
-      Key::Tab => write!(f, "<tab>"),
-      Key::Delete => write!(f, "<del>"),
-      _ => write!(f, "<{self:?}>"),
+      Key::Char(c) => write!(f, "{c}"),
+      Key::Ctrl(c) => write!(f, "ctrl-{c}"),
+      Key::Up => write!(f, "↑"),
+      Key::Down => write!(f, "↓"),
+      Key::Left => write!(f, "←"),
+      Key::Right => write!(f, "→"),
+      Key::PgDown => write!(f, "pgDown"),
+      Key::PgUp => write!(f, "pgUp"),
+      Key::Enter => write!(f, "enter"),
+      Key::Esc => write!(f, "esc"),
+      Key::Backspace => write!(f, "backspace"),
+      Key::Home => write!(f, "home"),
+      Key::End => write!(f, "end"),
+      Key::Tab => write!(f, "tab"),
+      Key::BackTab => write!(f, "shift-tab"),
+      Key::Delete => write!(f, "del"),
+      _ => write!(f, "{self:?}"),
     }
   }
 }
@@ -64,6 +70,14 @@ impl From<KeyEvent> for Key {
         code: KeyCode::Right,
         ..
       } => Key::Right,
+      KeyEvent {
+        code: KeyCode::PageDown,
+        ..
+      } => Key::PgDown,
+      KeyEvent {
+        code: KeyCode::PageUp,
+        ..
+      } => Key::PgUp,
       KeyEvent {
         code: KeyCode::Backspace,
         ..
@@ -75,6 +89,11 @@ impl From<KeyEvent> for Key {
       KeyEvent {
         code: KeyCode::End, ..
       } => Key::End,
+      KeyEvent {
+        code: KeyCode::BackTab,
+        modifiers: KeyModifiers::SHIFT,
+        ..
+      } => Key::BackTab,
       KeyEvent {
         code: KeyCode::Tab, ..
       } => Key::Tab,