Add comprehensive test suite

Unit and integration tests (tests/integration_tests.rs):
- config: API key resolution priority, file fallback, missing key errors
- params: parsing with/without =, api_key rejection, hashmap conversion,
  fields injection, duplicate-key last-write semantics
- error: display formatting, exit codes per variant (1/2/1)
- output: JSON rendering, nested objects, arrays
- jq: identity, field access, nested access, slicing, select, pipe, map,
  empty-filter error, null input, missing-key null return
- pagination: array merging, metadata preservation, pagination strip,
  cycle detection (canonical key, not string comparison)
- print_jq_value: content assertions for string/number/bool/null/object
- HOME_MUTEX at file top-level so all modules share it (fixes race)

End-to-end tests (tests/e2e.rs):
- Basic search, --fields, --jq, --all-pages (require SERPAPI_KEY)
- Account retrieval, location lookup, archive by ID
- Invalid API key, no-args exit code (no API key needed — not ignored)
- All remaining #[ignore] annotated with reason strings

Cycle detection test (tests/test_url_cycle.rs):
- Documents and tests the FIXED canonical cycle detection behavior
  (was documenting the old string-comparison bug as a known failure)

Author: ilyazub

tests/e2e.rs

@@ -0,0 +1,187 @@
+use assert_cmd::cargo_bin_cmd;
+use predicates::prelude::*;
+use std::env;
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_search_basic() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=coffee")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("search_metadata"));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_search_with_fields() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("--fields")
+        .arg("organic_results[0:2]")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=coffee")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("[").or(predicate::str::contains("{")));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_search_with_jq() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("--jq")
+        .arg(".search_metadata.id")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=coffee")
+        .assert()
+        .success()
+        // --jq uses raw scalar output (no quotes on strings), so just verify non-empty
+        .stdout(predicate::str::is_empty().not());
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_account() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("account")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("account_email").or(predicate::str::contains("plan")));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_locations() {
+    cargo_bin_cmd!("serpapi")
+        .arg("--json")
+        .arg("locations")
+        .arg("q=austin")
+        .arg("num=3")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("[").or(predicate::str::contains("canonical_name")));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_archive() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+
+    let search_output = cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=rust")
+        .output()
+        .unwrap();
+
+    if search_output.status.success() {
+        let output_str = String::from_utf8_lossy(&search_output.stdout);
+        if let Some(search_id_start) = output_str.find("search_id") {
+            if let Some(quote_start) = output_str[search_id_start..].find('"') {
+                let after_quote = search_id_start + quote_start + 1;
+                if let Some(quote_end) = output_str[after_quote..].find('"') {
+                    let search_id = &output_str[after_quote..after_quote + quote_end];
+                    if !search_id.is_empty() && search_id != "search_id" {
+                        cargo_bin_cmd!("serpapi")
+                            .arg("--api-key")
+                            .arg(&api_key)
+                            .arg("--json")
+                            .arg("archive")
+                            .arg(search_id)
+                            .assert()
+                            .success()
+                            .stdout(
+                                predicate::str::contains("search_metadata")
+                                    .or(predicate::str::contains("search_parameters")),
+                            );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+#[ignore = "requires SERPAPI_KEY"]
+fn test_search_all_pages() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg(&api_key)
+        .arg("--json")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=coffee")
+        .arg("num=1")
+        .arg("--all-pages")
+        .arg("--max-pages").arg("2")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("organic_results"));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_invalid_api_key() {
+    cargo_bin_cmd!("serpapi")
+        .arg("--api-key")
+        .arg("invalid")
+        .arg("--json")
+        .arg("search")
+        .arg("engine=google")
+        .arg("q=test")
+        .assert()
+        .failure()
+        .code(predicate::eq(1));
+}
+
+#[test]
+fn test_no_args() {
+    cargo_bin_cmd!("serpapi")
+        .assert()
+        .failure()
+        .code(predicate::eq(2));
+}
+
+#[test]
+#[ignore = "requires live SERPAPI_KEY env var"]
+fn test_login_flow() {
+    let api_key = env::var("SERPAPI_KEY").expect("SERPAPI_KEY not set");
+    let config_dir = serpapi_cli::config::config_dir();
+
+    let _ = std::fs::remove_file(config_dir.join("config.toml"));
+
+    cargo_bin_cmd!("serpapi")
+        .arg("login")
+        .write_stdin(format!("{}\n", api_key))
+        .assert()
+        .success();
+
+    assert!(
+        config_dir.join("config.toml").exists(),
+        "Config file should be created after login"
+    );
+}