html_simple_parser 0.1.1

A simple parser for html files to extract tags, child tags, attributes, etc.
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
102
103
104
105
106
107
108
109
110
111
112
113
114

use anyhow::{anyhow, Result};
use html_simple_parser::{parse_html, HtmlElem, HtmlParseError};

#[test]
fn thow_mismatched_closing_tag_error() -> Result<()> {
    let input = "<!DOCTYPE html>
                        <html>
                            <head> </head>
                        </div>";
    let result = parse_html(input);
    match result {
        Ok(_) => Err(anyhow!(
            "Test failed! There should be an error here due to tag mismatch."
        )),
        Err(HtmlParseError::MismatchedClosingTag(expected, found)) => {
            assert_eq!(expected, "html");
            assert_eq!(found, "div");
            Ok(())
        }
        Err(err) => Err(anyhow!(err).context("Test failed! Not the error that was expected.")),
    }
}

#[test]
fn invalid_html_structure() -> Result<()> {
    let input = "<!DOCTYPE html>
    <head> <head> <html> </head>
    </div>";
    let result = parse_html(input);
    match result {
        Ok(_) => Err(anyhow!(
            "Test failed! There should be an error here due to invalid structure."
        )),
        Err(HtmlParseError::ErrorHtmlStructure) => Ok(()),
        Err(err) => Err(anyhow!(err).context("Test failed! Not the error that was expected.")),
    }
}

#[test]
fn defining_right_tags() -> Result<()> {
    let input = "
    <!DOCTYPE html>
    <html> 
        <head>
            <p>Text</p>
            <br/>
        </head> 
    </html>";
    let result = parse_html(input);
    match result {
        Ok(elements) => {
            assert_eq!(elements.len(), 2);
            match &elements[0] {
                HtmlElem::Documentation(doctype) => {
                    assert_eq!("<!DOCTYPE html>", doctype);
                }
                _ => {
                    return Err(anyhow!(
                        "Test failed! First Element of html dom must be documentatation tag."
                    ))
                }
            }
            match &elements[1] {
                HtmlElem::Tag { tag_name, children } => {
                    assert_eq!("html", tag_name);
                    assert_eq!(children.len(), 1);
                    match &children[0] {
                        HtmlElem::Tag { tag_name, children } => {
                            assert_eq!("head", tag_name);
                            assert_eq!(children.len(), 2);
                            match &children[0] {
                                HtmlElem::Tag { tag_name, children } => {
                                    assert_eq!(tag_name, "p");
                                    assert_eq!(children.len(), 1);
                                    if let HtmlElem::Text(text) = &children[0] {
                                        assert_eq!(text, "Text");
                                    } else {
                                        return Err(anyhow!(
                                            "Test failed! <p> should contain text."
                                        ));
                                    }
                                }
                                _ => {
                                    return Err(anyhow!(
                                    "Test failed! The first child of <head> should be a <p> tag."
                                ))
                                }
                            }
                            match &children[1] {
                                HtmlElem::Tag { tag_name, children } => {
                                    assert_eq!(tag_name, "<br/>");
                                    assert!(children.is_empty());
                                }
                                _ => {
                                    return Err(anyhow!(
                                    "Test failed! The second child of <head> should be a <br> tag."
                                ))
                                }
                            }
                        }
                        _ => {
                            return Err(anyhow!(
                                "Test failed! The child of <html> should be a <head> tag."
                            ))
                        }
                    }
                }
                _ => return Err(anyhow!("Test failed! Second element must be tag.")),
            }
            Ok(())
        }
        Err(_) => Err(anyhow!("Test failed. HTML parsing failed.")),
    }
}