auditmysite 1.2.0

Resource-efficient WCAG 2.1 Accessibility Checker in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Error Handling Tests
//!
//! Tests for error paths and edge cases

use auditmysite::audit::read_url_file;
use auditmysite::error::AuditError;

#[test]
fn test_read_url_file_nonexistent() {
    let result = read_url_file("/nonexistent/path/to/file.txt");
    assert!(result.is_err());

    match result {
        Err(AuditError::FileError { path, reason }) => {
            assert!(path.to_string_lossy().contains("nonexistent"));
            assert!(!reason.is_empty());
        }
        _ => panic!("Expected FileError"),
    }
}

#[test]
fn test_read_url_file_filters_invalid_urls() {
    use std::io::Write;
    use std::time::{SystemTime, UNIX_EPOCH};

    // Create a temp file with mixed content
    let temp_dir = std::env::temp_dir();
    let unique = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system time before unix epoch")
        .as_nanos();
    let temp_file = temp_dir.join(format!("auditmysite-test-urls-{unique}.txt"));

    {
        let mut file = std::fs::File::create(&temp_file).unwrap();
        writeln!(file, "https://valid.com").unwrap();
        writeln!(file, "# This is a comment").unwrap();
        writeln!(file).unwrap();
        writeln!(file, "not-a-url").unwrap();
        writeln!(file, "ftp://invalid-scheme.com").unwrap();
        writeln!(file, "http://also-valid.com").unwrap();
        writeln!(file, "  https://with-whitespace.com  ").unwrap();
    }

    let result = read_url_file(temp_file.to_str().unwrap());

    // Clean up
    std::fs::remove_file(&temp_file).ok();

    let urls = result.expect("Should parse file");

    // Only valid http/https URLs should be included
    assert_eq!(urls.len(), 3);
    assert!(urls.contains(&"https://valid.com".to_string()));
    assert!(urls.contains(&"http://also-valid.com".to_string()));
    assert!(urls.contains(&"https://with-whitespace.com".to_string()));

    // Invalid entries should be filtered out
    assert!(!urls.iter().any(|u| u.contains("comment")));
    assert!(!urls.iter().any(|u| u.contains("not-a-url")));
    assert!(!urls.iter().any(|u| u.contains("ftp://")));
}

#[test]
fn test_audit_error_display() {
    let error = AuditError::ConfigError("Test error message".to_string());
    let display = format!("{}", error);
    assert!(display.contains("Test error message"));

    let nav_error = AuditError::NavigationFailed {
        url: "https://example.com".to_string(),
        reason: "Connection refused".to_string(),
    };
    let nav_display = format!("{}", nav_error);
    assert!(nav_display.contains("example.com"));
    assert!(nav_display.contains("Connection refused"));
}

#[test]
fn test_sitemap_parsing_error_types() {
    // Test that SitemapParseFailed error contains URL
    let error = AuditError::SitemapParseFailed {
        url: "https://example.com/sitemap.xml".to_string(),
        reason: "Invalid XML".to_string(),
    };

    let display = format!("{}", error);
    assert!(display.contains("sitemap.xml") || display.contains("Invalid XML"));
}

#[test]
fn test_page_timeout_error() {
    let error = AuditError::PageLoadTimeout {
        url: "https://slow-site.com".to_string(),
        timeout_secs: 30,
    };

    let display = format!("{}", error);
    assert!(display.contains("slow-site.com") || display.contains("30"));
}