adds test for tembo cloud using minimal example

.github/workflows/cargo-test.yaml

@@ -102,3 +102,9 @@ jobs:
           set -xe
           export PROMETHEUS_URL=https://prometheus-data-1.use1.dev.plat.cdb-svc.com
           cd ${{ matrix.path }} && cargo test
+        env:
+          ORG_ID: ${{ secrets.ORG_ID }}
+          ACCESS_TOKEN: ${{ secrets.ACCESS_TOKEN }}
+          TEMBO_HOST: ${{ secrets.TEMBO_HOST }}
+          TEMBO_DATA_HOST: ${{ secrets.TEMBO_DATA_HOST }}
+

tembo-cli/Cargo.toml

@@ -73,6 +73,7 @@ spinoff = "0.8.0"
 k8s-openapi = { version = "0.18.0", features = ["v1_25", "schemars"], default-features = false }
 tembo-stacks = "0.2.0"
 itertools = "0.12.1"
+random-string = "1.1.0"
 
 [target.aarch64-unknown-linux-musl.dependencies]
 openssl = { version = "0.10", features = ["vendored"] }

tembo-cli/src/cmd/apply.rs

@@ -22,7 +22,6 @@ use std::{
     thread::sleep,
     time::Duration,
 };
-use tembo::cli::tembo_config::Library;
 use tembo_stacks::apps::app::merge_app_reqs;
 use tembo_stacks::apps::app::merge_options;
 use tembo_stacks::apps::types::MergedConfigs;
@@ -49,6 +48,7 @@ use crate::cli::file_utils::FileUtils;
 use crate::cli::sqlx_utils::SqlxUtils;
 use crate::cli::tembo_config;
 use crate::cli::tembo_config::InstanceSettings;
+use crate::cli::tembo_config::Library;
 use crate::cli::tembo_config::OverlayInstanceSettings;
 use crate::cli::tembo_config::TrunkProject;
 use crate::tui;

tembo-cli/src/cmd/logs.rs

@@ -1,5 +1,5 @@
-use crate::apply::{get_instance_id, get_instance_settings};
 use crate::cli::context::{get_current_context, Target};
+use crate::cmd::apply::{get_instance_id, get_instance_settings};
 use anyhow::{Context, Result};
 use clap::Args;
 use reqwest::blocking::Client;

tembo-cli/src/cmd/top.rs

@@ -1,9 +1,9 @@
 use crate::cli::context::{get_current_context, Environment};
 use crate::cli::tembo_config::InstanceSettings;
 use crate::cmd::apply::get_instance_settings;
-use crate::Args;
 use anyhow::anyhow;
 use anyhow::{Context, Result};
+use clap::Args;
 use crossterm::{
     execute,
     terminal::{Clear, ClearType},

tembo-cli/src/cmd/validate.rs

@@ -1,11 +1,12 @@
-use crate::cli::context::{tembo_context_file_path, tembo_credentials_file_path};
+use crate::cli::context::{
+    list_context, list_credential_profiles, tembo_context_file_path, tembo_credentials_file_path,
+};
 use crate::cli::file_utils::FileUtils;
 use crate::cli::tembo_config::InstanceSettings;
 use crate::tui::{error, info, white_confirmation};
 use anyhow::Error;
 use clap::Args;
 use std::{collections::HashMap, fs, path::Path, str::FromStr};
-use tembo::cli::context::{list_context, list_credential_profiles};
 
 /// Validates the tembo.toml file, context file, etc.
 #[derive(Args)]

tembo-cli/tests/integration_tests_cloud.rs

@@ -0,0 +1,144 @@
+use assert_cmd::Command;
+use random_string::generate;
+use std::env;
+use std::error::Error;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use tembo::cli::context::{
+    get_current_context, tembo_context_file_path, tembo_credentials_file_path, Environment,
+};
+use temboclient::apis::configuration::Configuration;
+use temboclient::apis::instance_api::get_all;
+use temboclient::models::{Instance, State};
+
+const CARGO_BIN: &str = "tembo";
+
+#[tokio::test]
+async fn minimal_cloud() -> Result<(), Box<dyn Error>> {
+    let root_dir = env!("CARGO_MANIFEST_DIR");
+    let test_dir = PathBuf::from(root_dir).join("examples").join("minimal");
+
+    env::set_current_dir(&test_dir)?;
+
+    // tembo init
+    let mut cmd = Command::cargo_bin(CARGO_BIN)?;
+    cmd.arg("init");
+    cmd.assert().success();
+
+    let charset = "abcdefghijklmnopqrstuvwxyz";
+    let instance_name = generate(10, charset);
+
+    setup_env(&instance_name)?;
+
+    // tembo context set --name local
+    let mut cmd = Command::cargo_bin(CARGO_BIN)?;
+    cmd.arg("context");
+    cmd.arg("set");
+    cmd.arg("--name");
+    cmd.arg("prod");
+    cmd.assert().success();
+
+    // tembo apply
+    let mut cmd = Command::cargo_bin(CARGO_BIN).unwrap();
+    cmd.arg("apply");
+    cmd.assert().success();
+
+    let env = get_current_context()?;
+    let profile = env.clone().selected_profile.unwrap();
+    let config = Configuration {
+        base_path: profile.tembo_host,
+        bearer_access_token: Some(profile.tembo_access_token),
+        ..Default::default()
+    };
+
+    let maybe_instance = get_instance(&instance_name, &config, &env).await?;
+    if let Some(instance) = maybe_instance {
+        assert_eq!(instance.state, State::Up, "Instance isn't Up")
+    } else {
+        assert!(false, "Instance isn't Up")
+    }
+
+    // tembo delete
+    let mut cmd = Command::cargo_bin(CARGO_BIN)?;
+    cmd.arg("delete");
+    let _ = cmd.ok();
+
+    let maybe_instance = get_instance(&instance_name, &config, &env).await?;
+    if let Some(instance) = maybe_instance {
+        assert_eq!(instance.state, State::Deleting, "Instance isn't Deleting")
+    } else {
+        assert!(true, "Instance isn't Deleting")
+    }
+
+    Ok(())
+}
+
+fn setup_env(instance_name: &String) -> Result<(), Box<dyn Error>> {
+    replace_vars_in_file(tembo_context_file_path(), "ORG_ID", &env::var("ORG_ID")?)?;
+
+    replace_vars_in_file(
+        tembo_credentials_file_path(),
+        "ACCESS_TOKEN",
+        &env::var("ACCESS_TOKEN")?,
+    )?;
+
+    replace_vars_in_file(
+        tembo_credentials_file_path(),
+        "https://api.tembo.io",
+        &env::var("TEMBO_HOST")?,
+    )?;
+
+    replace_vars_in_file(
+        tembo_credentials_file_path(),
+        "https://api.data-1.use1.tembo.io",
+        &env::var("TEMBO_DATA_HOST")?,
+    )?;
+
+    replace_vars_in_file(
+        "tembo.toml".to_string(),
+        "instance_name = \"minimal\"",
+        &format!("instance_name = \"{instance_name}\""),
+    )?;
+
+    Ok(())
+}
+
+fn replace_vars_in_file(
+    file_path: String,
+    word_from: &str,
+    word_to: &str,
+) -> Result<(), Box<dyn Error>> {
+    let mut src = File::open(&file_path)?;
+    let mut data = String::new();
+    src.read_to_string(&mut data)?;
+    drop(src);
+    let new_data = data.replace(&*word_from, &*word_to);
+    let mut dst = File::create(&file_path)?;
+    dst.write(new_data.as_bytes())?;
+    Ok(())
+}
+
+pub async fn get_instance(
+    instance_name: &str,
+    config: &Configuration,
+    env: &Environment,
+) -> Result<Option<Instance>, anyhow::Error> {
+    let v = get_all(config, env.org_id.clone().unwrap().as_str()).await;
+
+    println!("OrgID: {}", env.org_id.clone().unwrap().as_str());
+
+    match v {
+        Ok(result) => {
+            let maybe_instance = result
+                .iter()
+                .find(|instance| instance.instance_name == instance_name);
+
+            if let Some(instance) = maybe_instance {
+                return Ok(Some(instance.clone()));
+            }
+        }
+        Err(error) => eprintln!("Error getting instance: {}", error),
+    };
+    Ok(None)
+}