spec-mock 0.1.0

CLI tool for spec-driven mock runtime supporting OpenAPI, AsyncAPI, and Protobuf
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
115
116

//! CLI entrypoint for standalone spec-mock runtime.

use std::net::SocketAddr;

use clap::{Parser, Subcommand, ValueEnum};
use specmock_core::MockMode;
use specmock_sdk::MockServer;

#[derive(Debug, Parser)]
#[command(
    name = "spec-mock",
    version,
    about = "Spec-driven mock runtime for OpenAPI/AsyncAPI/Protobuf"
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Debug, Subcommand)]
enum Commands {
    /// Start mock runtime.
    Serve(ServeArgs),
}

#[derive(Debug, Parser)]
struct ServeArgs {
    /// OpenAPI spec file path.
    #[arg(long)]
    openapi: Option<std::path::PathBuf>,
    /// AsyncAPI spec file path.
    #[arg(long)]
    asyncapi: Option<std::path::PathBuf>,
    /// Protobuf root .proto file path.
    #[arg(long)]
    proto: Option<std::path::PathBuf>,
    /// Runtime mode.
    #[arg(long, value_enum, default_value = "mock")]
    mode: ModeArg,
    /// Proxy upstream base URL.
    #[arg(long, required_if_eq("mode", "proxy"))]
    upstream: Option<String>,
    /// Deterministic data seed.
    #[arg(long, default_value_t = 42)]
    seed: u64,
    /// HTTP bind address.
    #[arg(long, default_value = "127.0.0.1:4010")]
    http_addr: SocketAddr,
    /// gRPC bind address.
    #[arg(long, default_value = "127.0.0.1:5010")]
    grpc_addr: SocketAddr,
    /// Maximum request body size in bytes.
    #[arg(long, default_value_t = 10_485_760)]
    max_body_size: usize,
}

#[derive(Debug, Clone, Copy, ValueEnum, Default)]
enum ModeArg {
    #[default]
    Mock,
    Proxy,
}

impl ModeArg {
    const fn into_runtime_mode(self) -> MockMode {
        match self {
            Self::Mock => MockMode::Mock,
            Self::Proxy => MockMode::Proxy,
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), eyre::Report> {
    tracing_subscriber::fmt().with_target(false).with_level(true).compact().init();

    let cli = Cli::parse();
    match cli.command {
        Commands::Serve(args) => serve_command(args).await?,
    }

    Ok(())
}

async fn serve_command(args: ServeArgs) -> Result<(), eyre::Report> {
    let mut builder = MockServer::builder()
        .seed(args.seed)
        .mode(args.mode.into_runtime_mode())
        .http_addr(args.http_addr)
        .grpc_addr(args.grpc_addr)
        .max_body_size(args.max_body_size);

    if let Some(openapi) = args.openapi {
        builder = builder.openapi(openapi);
    }
    if let Some(asyncapi) = args.asyncapi {
        builder = builder.asyncapi(asyncapi);
    }
    if let Some(proto) = args.proto {
        builder = builder.proto(proto);
    }
    if let Some(upstream) = args.upstream {
        builder = builder.upstream(upstream);
    }

    let server = builder.start().await?;
    tracing::info!("HTTP: {}", server.http_base_url());
    if let Some(grpc_addr) = server.grpc_addr() {
        tracing::info!("gRPC: {grpc_addr}");
    }
    tracing::info!("Press Ctrl+C to stop");

    tokio::signal::ctrl_c().await?;
    server.shutdown().await;
    Ok(())
}