sqlness-cli 0.6.1

SQLNESS command line tool
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
117
118
119
120
121
122
123
124
125

// Copyright 2023 CeresDB Project Authors. Licensed under Apache-2.0.

use std::{fmt::Display, path::Path};

use async_trait::async_trait;
use clap::Parser;
use futures::executor::block_on;
use sqlness::{
    database_impl::{mysql::MysqlDatabase, postgresql::PostgresqlDatabase},
    ConfigBuilder, Database, DatabaseConfig, DatabaseConfigBuilder, EnvController, QueryContext,
    Runner,
};

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
/// A cli to run sqlness tests.
struct Args {
    /// Directory of test cases
    #[clap(short, long, required(true))]
    case_dir: String,

    /// IP of database to test against
    #[clap(short, long, required(true))]
    ip: String,

    /// Port of database to test against
    #[clap(short, long, required(true))]
    port: u16,

    /// User of database to test against
    #[clap(short, long, required(false))]
    user: Option<String>,

    /// Password of database to test against
    #[clap(short('P'), long, required(false))]
    password: Option<String>,

    /// DB name of database to test against
    #[clap(short, long)]
    db: Option<String>,

    /// Which DBMS to test against
    #[clap(short('t'), long("type"))]
    #[arg(value_enum, default_value_t)]
    db_type: DBType,
}

#[derive(clap::ValueEnum, Clone, Debug, Default, Copy)]
enum DBType {
    #[default]
    Mysql,
    Postgresql,
}

struct DBProxy {
    database: Box<dyn Database + Sync + Send>,
}

#[async_trait]
impl Database for DBProxy {
    async fn query(&self, context: QueryContext, query: String) -> Box<dyn Display> {
        self.database.query(context, query).await
    }
}

impl DBProxy {
    pub fn new(db_config: DatabaseConfig, db_type: DBType) -> Self {
        let database: Box<dyn Database + Sync + Send> = match db_type {
            DBType::Mysql => Box::new(MysqlDatabase::try_new(db_config).expect("build mysql db")),
            DBType::Postgresql => {
                Box::new(PostgresqlDatabase::try_new(&db_config).expect("build postgresql db"))
            }
        };

        DBProxy { database }
    }
}

struct CliController {
    db_config: DatabaseConfig,
    db_type: DBType,
}

impl CliController {
    fn new(db_config: DatabaseConfig, db_type: DBType) -> Self {
        Self { db_config, db_type }
    }
}

#[async_trait]
impl EnvController for CliController {
    type DB = DBProxy;

    async fn start(&self, _env: &str, _config: Option<&Path>) -> Self::DB {
        DBProxy::new(self.db_config.clone(), self.db_type)
    }

    async fn stop(&self, _env: &str, _db: Self::DB) {}
}

fn main() {
    println!("Begin run tests...");
    let args = Args::parse();
    let db_config = DatabaseConfigBuilder::default()
        .ip_or_host(args.ip)
        .tcp_port(args.port)
        .user(args.user)
        .pass(args.password)
        .db_name(args.db)
        .build()
        .expect("build db config");

    let config = ConfigBuilder::default()
        .case_dir(args.case_dir)
        .build()
        .expect("build config");

    block_on(async {
        let ctrl = CliController::new(db_config, args.db_type);
        let runner = Runner::new(config, ctrl);
        runner.run().await.expect("run testcase")
    });

    println!("Test run finish");
}