reqsh 0.3.3

Interactive HTTP shell for API workflows
Documentation
use std::fmt;

use crate::{
    ast::{Command, RequestSpec},
    http::{Client, HttpResponse, describe_request_error},
    session::Session,
};

mod request;
mod session;
mod shell;
mod variable;

pub struct Executor {
    client: Client,
}

pub enum ControlFlow {
    Continue,
    Exit,
}

#[derive(Debug)]
pub enum Output {
    None,
    Text(String),
    HttpResponse {
        request_line: String,
        response: HttpResponse,
    },
}

pub struct ExecutionResult {
    pub control_flow: ControlFlow,
    pub output: Output,
}

#[derive(Debug)]
pub enum ExecutionError {
    InvalidRequest(String),
    RequestFailed(String),
    NoRequestToSave,
    SavedRequestNotFound(String),
    NoResponseToSave,
    NoRequestToReplay,
    WriteResponse { path: String, message: String },
}

impl fmt::Display for ExecutionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ExecutionError::InvalidRequest(message) => write!(f, "{message}"),
            ExecutionError::RequestFailed(message) => write!(f, "request failed: {message}"),
            ExecutionError::NoRequestToSave => {
                write!(
                    f,
                    "no request to save; run a request first, then use `req save <name>`"
                )
            }
            ExecutionError::SavedRequestNotFound(name) => {
                write!(f, "no saved request: {name}")
            }
            ExecutionError::NoResponseToSave => {
                write!(f, "no response to save; run a request first")
            }
            ExecutionError::NoRequestToReplay => {
                write!(f, "no request to replay; run a request first")
            }
            ExecutionError::WriteResponse { path, message } => {
                write!(f, "failed to write response to {path}: {message}")
            }
        }
    }
}

impl std::error::Error for ExecutionError {}

impl Default for Executor {
    fn default() -> Self {
        Self::new()
    }
}

impl Executor {
    pub fn new() -> Self {
        Self {
            client: Client::new(),
        }
    }

    pub fn execute(
        &mut self,
        command: Command,
        session: &mut Session,
    ) -> Result<ExecutionResult, ExecutionError> {
        match command {
            Command::Session(command) => self.execute_session(command, session),

            Command::Variable(command) => Ok(self.execute_variable(command, session)),

            Command::Shell(command) => Ok(self.execute_shell(command)),

            Command::History(_) => Ok(ExecutionResult {
                control_flow: ControlFlow::Continue,
                output: Output::None,
            }),

            Command::Request(command) => self.execute_request(command, session),

            Command::Http(spec) => {
                *session.last_request() = Some(spec.clone());
                self.send_spec(spec, session)
            }
        }
    }

    fn send_spec(
        &mut self,
        spec: RequestSpec,
        session: &mut Session,
    ) -> Result<ExecutionResult, ExecutionError> {
        let request = session
            .build_request(spec)
            .map_err(ExecutionError::InvalidRequest)?;

        let request_line = format!("{} {}", request.method, request.url);

        let response = self
            .client
            .send(request)
            .map_err(|e| ExecutionError::RequestFailed(describe_request_error(&e)))?;

        *session.last_response() = Some(response.clone());

        Ok(ExecutionResult {
            control_flow: ControlFlow::Continue,
            output: Output::HttpResponse {
                request_line,
                response,
            },
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ast::{Command, Method, RequestSpec};

    #[test]
    fn connection_refused_is_described_gracefully() {
        let mut session = Session::new();
        let spec = RequestSpec {
            method: Method::Get,
            path: "http://127.0.0.1:1/".to_string(),
            headers: Vec::new(),
            queries: Vec::new(),
            body: String::new(),
        };

        let result = Executor::new().execute(Command::Http(spec), &mut session);

        assert!(matches!(
            result,
            Err(ExecutionError::RequestFailed(ref message))
                if message.contains("connection refused")
        ));
    }
}