alixt 0.8.0

A command line http API testing utility with TOML configuration
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

// This file is part of alixt.
// Copyright (C) 2025 Devon Harley Offutt
//
// alixt is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.

pub mod execute;
pub mod models;
pub mod reporting;
pub mod utils;

use std::{path::Path, sync::Arc};

use reqwest::Client;

use crate::{
    models::{
        cli::OutputFormat, config::Config, context::Global, error::AlixtError, plan::TestPlan,
    },
    reporting::render::{generate_json, generate_table, generate_text},
    utils::env,
};

pub async fn run<W: std::io::Write>(
    writer: &mut W,
    args: models::cli::Args,
) -> Result<(), AlixtError> {
    let Some(config_file) = args.file else {
        return Err(AlixtError::InternalError(
            "Somehow an arg.file containing None got into run()".to_string(),
        ));
    };
    let content = std::fs::read_to_string(&config_file)?;
    let config: Config = toml::from_str(&content)?;
    let config_dir = std::fs::canonicalize(&config_file)?
        .parent()
        .unwrap_or_else(|| Path::new("."))
        .to_owned();

    let plan = TestPlan::from_config(config, &config_dir)?;

    #[allow(unused)]
    let mut global = Global::new();
    let client = Client::builder()
        .danger_accept_invalid_certs(args.insecure)
        .build()?;

    if let Some(capture_plan) = &plan.capture {
        if let Some(env_map) = &capture_plan.environment_variables {
            let dot_env_vars = if let Some(path) = &capture_plan.env_file {
                Some(env::load_env_file(path)?)
            } else {
                None
            };

            let captured = env::capture_system_environment(env_map, dot_env_vars)?;

            global.env_variables.extend(captured);
        }

        if let Some(requests) = &capture_plan.requests {
            for request in requests {
                execute::http::execute_capture_request(&client, request, &mut global).await?;
            }
        }
    }

    let global = Arc::new(global);
    let outcome = execute::http::execute_test(&client, plan, global).await?;

    match args.mode {
        OutputFormat::Text => {
            generate_text(writer, outcome)?;
        }
        OutputFormat::Table => {
            generate_table(writer, outcome, args.verbose)?;
        }
        OutputFormat::Json => {
            generate_json(writer, outcome)?;
        }
    }
    Ok(())
}