sql-fun-core 0.1.1

common dependencies for sql-fun
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
99
100
101
102
103
104
105
106
107
108
109
110

use std::path::{Path, PathBuf};

use crate::SqlFunArgsError;

impl super::SqlFunArgs {
    /// gets metadata format value in args
    #[must_use]
    pub fn metadata_format(&self) -> &str {
        self.metadata_args.metadata_format()
    }

    /// return raw value for `--metadata-file`
    ///
    /// # Errors
    ///
    /// Returns [`SqlFunArgsError::NotSupported`] if the metadata format is not `TOML`.
    pub fn metadata_file_raw(&self) -> Result<&str, SqlFunArgsError> {
        self.metadata_args.metadata_file_raw()
    }

    /// search metadata file with same-owner policy
    ///
    /// # Errors
    ///
    /// Propagates errors when current directory or metadata path resolution fails.
    pub fn metadata_file(&self) -> Result<PathBuf, SqlFunArgsError> {
        self.metadata_args.metadata_file()
    }

    /// get schema file
    ///
    /// # Errors
    ///
    /// Returns [`SqlFunArgsError::FilePathNotFound`] when the schema file is missing.
    pub fn schema_file(&self, metadata_file: &Path) -> Result<PathBuf, SqlFunArgsError> {
        self.metadata_args.schema_file(metadata_file)
    }
}

#[cfg(test)]
mod test_metadata {
    use std::str::FromStr;

    use clap::{Parser, builder::OsStr};
    use testresult::TestResult;

    use crate::{SqlDialect, SqlFunArgs, SqlFunMetadata, metadata::EngineVersion};

    #[test]
    pub fn test_metadata_format() -> TestResult {
        let args = SqlFunArgs::try_parse_from(vec![
            "sqlfun",
            "--sql-fun-home",
            "../sql-fun-home",
            "subcmd",
        ])?;
        let metadata_format = args.metadata_format();
        assert_eq!(metadata_format, "TOML");
        Ok(())
    }

    #[test]
    pub fn test_metadata_file_raw() -> TestResult {
        let args = SqlFunArgs::try_parse_from(vec![
            "sqlfun",
            "--sql-fun-home",
            "../sql-fun-home",
            "subcmd",
        ])?;
        let metadata_file_raw = args.metadata_file_raw()?;
        assert_eq!(metadata_file_raw, "Cargo.toml");
        Ok(())
    }

    #[test]
    pub fn test_metadata_file() -> TestResult {
        let args = SqlFunArgs::try_parse_from(vec![
            "sqlfun",
            "--sql-fun-home",
            "../sql-fun-home",
            "subcmd",
        ])?;
        let metadata_file = args.metadata_file()?;
        assert_eq!(
            metadata_file.parent().unwrap().file_stem().unwrap(),
            OsStr::from("sql-fun-core")
        );
        Ok(())
    }

    #[test]
    pub fn test_metadata_file_load() -> TestResult {
        let args = SqlFunArgs::try_parse_from(vec![
            "sqlfun",
            "--sql-fun-home",
            "../sql-fun-home",
            "--metadata-file",
            "test-assets/metadata.toml",
            "subcmd",
        ])?;
        let metadata_file = args.metadata_file()?;
        let metadata = SqlFunMetadata::load_from(metadata_file)?;
        let sql_dialect = metadata.sql_dialect();
        assert_eq!(sql_dialect, SqlDialect::PostgreSQL);
        let engine_version = metadata.engine_version();
        assert_eq!(engine_version, &Some(EngineVersion::from_str("17")?));

        Ok(())
    }
}