hurl 8.0.0

Hurl, run and test HTTP requests
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

/*
 * Hurl (https://hurl.dev)
 * Copyright (C) 2026 Orange
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
use hurl_core::input::Input;

use crate::report::ReportError;
use crate::runner::HurlResult;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Testcase {
    pub(crate) description: String,
    pub(crate) success: bool,
}

impl Testcase {
    /// Creates an Tap <testcase> from an [`HurlResult`].
    pub fn from(hurl_result: &HurlResult, filename: &Input) -> Testcase {
        let description = filename.to_string();
        let success = hurl_result.errors().is_empty();
        Testcase {
            description,
            success,
        }
    }

    /// Creates an Tap <testcase> from a TAP line
    /// ok 1 - this is the first test
    /// nok 2 - this is the second test
    pub fn parse(line: &str) -> Result<Testcase, ReportError> {
        let mut line = line;
        let success = if line.starts_with("ok") {
            line = &line[2..];
            true
        } else if line.starts_with("not ok") {
            line = &line[6..];
            false
        } else {
            return Err(ReportError::from_string(&format!(
                "Invalid TAP line <{line}> - must start with ok or nok"
            )));
        };

        let description = match line.find('-') {
            None => {
                return Err(ReportError::from_string(&format!(
                    "Invalid TAP line <{line}> - missing '-' separator"
                )));
            }
            Some(index) => {
                if line.split_at(index).0.trim().parse::<usize>().is_err() {
                    return Err(ReportError::from_string(&format!(
                        "Invalid TAP line <{line}> - missing test number"
                    )));
                }
                line.split_at(index).1[1..].trim().to_string()
            }
        };
        Ok(Testcase {
            description,
            success,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_tap_test_line() {
        assert_eq!(
            Testcase::parse("toto").err().unwrap().to_string(),
            "Invalid TAP line <toto> - must start with ok or nok".to_string()
        );

        assert_eq!(
            Testcase::parse("ok 1 - tests_ok/test.1.hurl").unwrap(),
            Testcase {
                description: "tests_ok/test.1.hurl".to_string(),
                success: true
            }
        );
    }
}