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

use schema_core::{
    commands::apply_migrations,
    json_rpc::types::*,
    schema_connector::{Namespaces, SchemaConnector},
    CoreError, CoreResult,
};
use tempfile::TempDir;

#[must_use = "This struct does nothing on its own. See ApplyMigrations::send()"]
pub struct ApplyMigrations<'a> {
    api: &'a mut dyn SchemaConnector,
    migrations_directory: &'a TempDir,
    namespaces: Option<Namespaces>,
}

impl<'a> ApplyMigrations<'a> {
    pub fn new(
        api: &'a mut dyn SchemaConnector,
        migrations_directory: &'a TempDir,
        mut namespaces: Vec<String>,
    ) -> Self {
        let namespaces = Namespaces::from_vec(&mut namespaces);

        ApplyMigrations {
            api,
            migrations_directory,
            namespaces,
        }
    }

    pub async fn send(self) -> CoreResult<ApplyMigrationsAssertion<'a>> {
        let output = apply_migrations(
            ApplyMigrationsInput {
                migrations_directory_path: self.migrations_directory.path().to_str().unwrap().to_owned(),
            },
            self.api,
            self.namespaces,
        )
        .await?;

        Ok(ApplyMigrationsAssertion {
            output,
            _migrations_directory: self.migrations_directory,
        })
    }

    #[track_caller]
    pub fn send_sync(self) -> ApplyMigrationsAssertion<'a> {
        test_setup::runtime::run_with_thread_local_runtime(self.send()).unwrap()
    }

    #[track_caller]
    pub fn send_unwrap_err(self) -> CoreError {
        test_setup::runtime::run_with_thread_local_runtime(self.send()).unwrap_err()
    }
}

pub struct ApplyMigrationsAssertion<'a> {
    output: ApplyMigrationsOutput,
    _migrations_directory: &'a TempDir,
}

impl std::fmt::Debug for ApplyMigrationsAssertion<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ApplyMigrationsAssertion {{ .. }}")
    }
}

impl<'a> ApplyMigrationsAssertion<'a> {
    #[track_caller]
    pub fn assert_applied_migrations(self, names: &[&str]) -> Self {
        let found_names: Vec<&str> = self
            .output
            .applied_migration_names
            .iter()
            .map(|name| &name[15..])
            .collect();

        assert!(
            found_names == names,
            "Assertion failed. The applied migrations do not match the expectations. ({found_names:?} vs {names:?})"
        );
        self
    }

    pub fn into_output(self) -> ApplyMigrationsOutput {
        self.output
    }
}