dagger-rs/crates/dagger-sdk/examples/test-the-application/main.rs

use dagger_sdk::HostDirectoryOpts;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let client = dagger_sdk::connect().await?;

    let host_source_dir = client.host().directory_opts(
        "examples/test-the-application/app",
        HostDirectoryOpts {
            exclude: Some(vec!["node_modules", "ci/"]),
            include: None,
        },
    );

    let source = client
        .container()
        .from("node:16")
        .with_mounted_directory("/src", host_source_dir.id().await?);

    let runner = source
        .with_workdir("/src")
        .with_exec(vec!["npm", "install"]);

    let out = runner
        .with_exec(vec!["npm", "test", "--", "--watchAll=false"])
        .stderr().await?;

    println!("{}", out);

    Ok(())
}
feat(sdk): re-export through lib.rs this means that you can now use dagger_sdk::connect() instead of dagger_sdk::client::connect(); 2023-02-19 15:24:37 +01:00			`use dagger_sdk::HostDirectoryOpts;`
add test-the-application 2023-02-17 15:34:18 +01:00
feat(sdk,core): Use async runtime instead of blocking. Default to using async runtime instead of blocking. I.e. ```rust fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere")?; // ... } // to async fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere").await?; // ... } ``` 2023-02-19 21:37:54 +01:00			`#[tokio::main]`
			`async fn main() -> eyre::Result<()> {`
fix(core): Fix async panic on blocking #19 Replaced internal threads with tokio spawn functions 2023-02-20 10:10:42 +01:00			`let client = dagger_sdk::connect().await?;`
add test-the-application 2023-02-17 15:34:18 +01:00
feat(sdk): with _opts methods Now all opt values enter into a _opts function instead of the original. This avoids a lot of verbosity for both None in the case opts are unwanted, and Some() if they actually are. They are used like so: ```rust client.container().from("..."); client.container_opts(Some(ContainerOpts{ ... })) ``` Some from opts will be removed in a future commit/pr 2023-02-19 17:43:12 +01:00			`let host_source_dir = client.host().directory_opts(`
feat(sdk): move to &str instead of String and introduce builder. This will make the api much easier to use, as we can now rely on "" instead of "".into() for normal string values. Introduced builder as well, which makes it much easier to use *Opts, as it can handle the building of that, and get the benefits from String -> &str, as that is currently not allowed for optional values 2023-02-19 17:21:40 +01:00			`"examples/test-the-application/app",`
feat(sdk): without Some in _opts functions Option has been removed as a wrapper around opts. This makes it much more convenient to use ```rust client.container_opts(Some(ContainerOpts{})) // -> client.container_opts(ContainerOpts{}) ``` The same options are still available, either an empty object can be passed, or a non _opts function can be used 2023-02-19 17:49:22 +01:00			`HostDirectoryOpts {`
feat(sdk): move to &str instead of String and introduce builder. This will make the api much easier to use, as we can now rely on "" instead of "".into() for normal string values. Introduced builder as well, which makes it much easier to use *Opts, as it can handle the building of that, and get the benefits from String -> &str, as that is currently not allowed for optional values 2023-02-19 17:21:40 +01:00			`exclude: Some(vec!["node_modules", "ci/"]),`
add test-the-application 2023-02-17 15:34:18 +01:00			`include: None,`
feat(sdk): without Some in _opts functions Option has been removed as a wrapper around opts. This makes it much more convenient to use ```rust client.container_opts(Some(ContainerOpts{})) // -> client.container_opts(ContainerOpts{}) ``` The same options are still available, either an empty object can be passed, or a non _opts function can be used 2023-02-19 17:49:22 +01:00			`},`
add test-the-application 2023-02-17 15:34:18 +01:00			`);`

			`let source = client`
feat(sdk): with _opts methods Now all opt values enter into a _opts function instead of the original. This avoids a lot of verbosity for both None in the case opts are unwanted, and Some() if they actually are. They are used like so: ```rust client.container().from("..."); client.container_opts(Some(ContainerOpts{ ... })) ``` Some from opts will be removed in a future commit/pr 2023-02-19 17:43:12 +01:00			`.container()`
feat(sdk): move to &str instead of String and introduce builder. This will make the api much easier to use, as we can now rely on "" instead of "".into() for normal string values. Introduced builder as well, which makes it much easier to use *Opts, as it can handle the building of that, and get the benefits from String -> &str, as that is currently not allowed for optional values 2023-02-19 17:21:40 +01:00			`.from("node:16")`
feat(sdk,core): Use async runtime instead of blocking. Default to using async runtime instead of blocking. I.e. ```rust fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere")?; // ... } // to async fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere").await?; // ... } ``` 2023-02-19 21:37:54 +01:00			`.with_mounted_directory("/src", host_source_dir.id().await?);`
add test-the-application 2023-02-17 15:34:18 +01:00
			`let runner = source`
feat(sdk): move to &str instead of String and introduce builder. This will make the api much easier to use, as we can now rely on "" instead of "".into() for normal string values. Introduced builder as well, which makes it much easier to use *Opts, as it can handle the building of that, and get the benefits from String -> &str, as that is currently not allowed for optional values 2023-02-19 17:21:40 +01:00			`.with_workdir("/src")`
feat(sdk): with _opts methods Now all opt values enter into a _opts function instead of the original. This avoids a lot of verbosity for both None in the case opts are unwanted, and Some() if they actually are. They are used like so: ```rust client.container().from("..."); client.container_opts(Some(ContainerOpts{ ... })) ``` Some from opts will be removed in a future commit/pr 2023-02-19 17:43:12 +01:00			`.with_exec(vec!["npm", "install"]);`
add test-the-application 2023-02-17 15:34:18 +01:00
			`let out = runner`
feat(sdk): with _opts methods Now all opt values enter into a _opts function instead of the original. This avoids a lot of verbosity for both None in the case opts are unwanted, and Some() if they actually are. They are used like so: ```rust client.container().from("..."); client.container_opts(Some(ContainerOpts{ ... })) ``` Some from opts will be removed in a future commit/pr 2023-02-19 17:43:12 +01:00			`.with_exec(vec!["npm", "test", "--", "--watchAll=false"])`
feat(sdk,core): Use async runtime instead of blocking. Default to using async runtime instead of blocking. I.e. ```rust fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere")?; // ... } // to async fn main() -> eyre::Result<()> { // ... client.container().from("rust").publish("somewhere").await?; // ... } ``` 2023-02-19 21:37:54 +01:00			`.stderr().await?;`
add test-the-application 2023-02-17 15:34:18 +01:00
			`println!("{}", out);`

			`Ok(())`
			`}`