organic/src/bin_foreign_document_test.rs

#![feature(round_char_boundary)]
#![feature(exact_size_is_empty)]
use std::io::Read;
use std::path::Path;
use std::path::PathBuf;

use organic::compare::run_anonymous_compare;
use organic::compare::run_compare_on_file;

#[cfg(feature = "tracing")]
use crate::init_tracing::init_telemetry;
#[cfg(feature = "tracing")]
use crate::init_tracing::shutdown_telemetry;
#[cfg(feature = "tracing")]
mod init_tracing;

#[cfg(not(feature = "tracing"))]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Runtime::new()?;
    let result = rt.block_on(async {
        let main_body_result = main_body().await;
        main_body_result
    });
    result
}

#[cfg(feature = "tracing")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Runtime::new()?;
    let result = rt.block_on(async {
        init_telemetry()?;
        let main_body_result = main_body().await;
        shutdown_telemetry()?;
        main_body_result
    });
    result
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
async fn main_body() -> Result<(), Box<dyn std::error::Error>> {
    let single_file = TestConfig::SingleFile(SingleFile {
        file_path: PathBuf::from("/tmp/test.org"),
    });
    // let result = single_file.run_test().await;
    let result = tokio::spawn(single_file.run_test());
    println!("{:?}", result);
    // let test_config = TestConfig::TestLayer(TestLayer {
    //     name: "foo",
    //     children: vec![TestConfig::SingleFile(SingleFile {
    //         file_path: Path::new("/tmp/test.org"),
    //     })],
    // });
    Ok(())
}

#[derive(Debug)]
enum TestConfig {
    TestLayer(TestLayer),
    SingleFile(SingleFile),
}

#[derive(Debug)]
struct TestLayer {
    name: String,
    children: Vec<TestConfig>,
}

#[derive(Debug)]
struct SingleFile {
    file_path: PathBuf,
}

#[derive(Debug)]
enum TestResult {
    ResultLayer(ResultLayer),
    SingleFileResult(SingleFileResult),
}

#[derive(Debug)]
struct ResultLayer {
    name: String,
    children: Vec<TestResult>,
}

#[derive(Debug)]
struct SingleFileResult {
    file_path: PathBuf,
    status: TestStatus,
}

#[derive(Debug)]
pub(crate) enum TestStatus {
    Good,
    Bad,
}

impl TestConfig {
    async fn run_test(self) -> TestResult {
        match self {
            TestConfig::TestLayer(test) => TestResult::ResultLayer(test.run_test().await),
            TestConfig::SingleFile(test) => TestResult::SingleFileResult(test.run_test().await),
        }
    }
}

impl SingleFile {
    async fn run_test(self) -> SingleFileResult {
        let result = run_compare_on_file(&self.file_path);
        SingleFileResult {
            file_path: self.file_path,
            status: if result.is_ok() {
                TestStatus::Good
            } else {
                TestStatus::Bad
            },
        }
    }
}

impl TestLayer {
    async fn run_test(self) -> ResultLayer {
        let mut children = Vec::with_capacity(self.children.len());
        for config in self.children {
            let result = config.run_test().await;
            children.push(result);
        }
        ResultLayer {
            name: self.name,
            children,
        }
    }
}