integration test command

images/haze/misc/integration

@@ -1,4 +1,4 @@
 #!/bin/sh 
 
 cd $WEBROOT/build/integration
-sudo -u www-data ./run.sh "$@"
+./run.sh "$@"

src/args.rs

@@ -45,6 +45,10 @@ pub enum HazeArgs {
     Fmt {
         path: String,
     },
+    Integration {
+        options: CloudOptions,
+        args: Vec<String>,
+    },
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -103,6 +107,12 @@ impl HazeArgs {
                 let args = args.map(S::into).collect();
                 Ok(HazeArgs::Test { options, args })
             }
+            HazeCommand::Integration => {
+                let mut args = args.peekable();
+                let options = CloudOptions::parse(&mut args)?;
+                let args = args.map(S::into).collect();
+                Ok(HazeArgs::Integration { options, args })
+            }
             HazeCommand::Exec => {
                 let mut args = args.peekable();
 
@@ -171,6 +181,7 @@ pub enum HazeCommand {
     Logs,
     Open,
     Fmt,
+    Integration,
 }
 
 impl FromStr for HazeCommand {
@@ -190,6 +201,7 @@ impl FromStr for HazeCommand {
             "open" => Ok(HazeCommand::Open),
             "fmt" => Ok(HazeCommand::Fmt),
             "format" => Ok(HazeCommand::Fmt),
+            "integration" => Ok(HazeCommand::Integration),
             _ => Err(Report::msg(format!("Unknown command: {}", s))),
         }
     }
@@ -209,6 +221,7 @@ impl HazeCommand {
             HazeCommand::Logs => true,
             HazeCommand::Open => true,
             HazeCommand::Fmt => false,
+            HazeCommand::Integration => false,
         }
     }
 }

src/exec.rs

@@ -108,6 +108,7 @@ pub async fn exec<S1: AsRef<str>, S2: Into<String>>(
         attach_stdout: Some(true),
         attach_stderr: Some(true),
         env: Some(env),
+        tty: Some(true),
         ..Default::default()
     };
     let message = docker

src/main.rs

@@ -214,6 +214,30 @@ async fn main() -> Result<()> {
             cloud.exec(&mut docker, args, false).await?;
             cloud.destroy(&mut docker).await?;
         }
+        HazeArgs::Integration { options, mut args } => {
+            let cloud = Cloud::create(&mut docker, options, &config).await?;
+            println!("Waiting for servers to start");
+            cloud.wait_for_start(&mut docker).await?;
+            println!("Installing");
+            if let Err(e) = cloud
+                .exec(
+                    &mut docker,
+                    vec![
+                        "install",
+                        &config.auto_setup.username,
+                        &config.auto_setup.password,
+                    ],
+                    false,
+                )
+                .await
+            {
+                cloud.destroy(&mut docker).await?;
+                return Err(e);
+            }
+            args.insert(0, "integration".to_string());
+            cloud.exec(&mut docker, args, false).await?;
+            cloud.destroy(&mut docker).await?;
+        }
         HazeArgs::Fmt { path } => {
             let cloud = Cloud::create(&mut docker, CloudOptions::default(), &config).await?;
             let mut out_buffer = Vec::<u8>::with_capacity(1024);