feat: add tests

Signed-off-by: kjuulh <contact@kjuulh.io>

Cargo.lock

@@ -1178,6 +1178,7 @@ dependencies = [
  "axum 0.7.4",
  "clap",
  "dotenv",
+ "lazy_static",
  "mockall",
  "mockall_double",
  "nats",

crates/flux-releaser/Cargo.toml

@@ -28,4 +28,5 @@ tar = "0.4.40"
 tonic-build = "0.11.0"
 
 [dev-dependencies]
+lazy_static = "1.4.0"
 mockall = "0.12.1"

crates/flux-releaser/src/cli.rs

@@ -1,12 +1,6 @@
 use clap::{Parser, Subcommand};
 use std::net::SocketAddr;
 
-use crate::{
-    api::axum_serve,
-    app::{App, SharedApp},
-    grpc::tonic_serve,
-};
-
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, subcommand_required = true)]
 pub struct Command {
@@ -29,6 +23,26 @@ impl Command {
         let cli = Command::parse();
 
         if let Some(Commands::Serve { host, grpc_host }) = cli.command {
+            server::run_server(host, grpc_host).await?;
+        }
+
+        Ok(())
+    }
+}
+
+pub mod server {
+    use std::net::SocketAddr;
+
+    use crate::{
+        api::axum_serve,
+        app::{App, SharedApp},
+        grpc::tonic_serve,
+    };
+
+    pub async fn run_server(
+        host: impl Into<SocketAddr>,
+        grpc_host: impl Into<SocketAddr>,
+    ) -> anyhow::Result<()> {
         tracing_subscriber::fmt::init();
 
         tracing::info!("Starting service");
@@ -36,14 +50,13 @@ impl Command {
         let app = SharedApp::new(App::new().await?);
 
         tokio::select! {
-                res = axum_serve(host, app.clone()) => {
+            res = axum_serve(host.into(), app.clone()) => {
               res?;
             },
-                res = tonic_serve(grpc_host, app.clone()) => {
+            res = tonic_serve(grpc_host.into(), app.clone()) => {
               res?;
             },
         };
-        }
 
         Ok(())
     }

crates/flux-releaser/tests/publish_artifacts.rs

@@ -0,0 +1,48 @@
+struct Server {}
+
+impl Server {
+    pub async fn new() -> Self {
+        Self {}
+    }
+
+    pub async fn start(&self) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+
+static INIT: std::sync::Once = std::sync::Once::new();
+
+// Makes sure the setup is ready for execution
+async fn is_ready() -> anyhow::Result<()> {
+    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+    Ok(())
+}
+
+async fn setup() -> anyhow::Result<()> {
+    INIT.call_once(|| {
+        tokio::spawn(async move {
+            println!("once was created once");
+            Server::new().await.start().await.unwrap();
+        });
+    });
+
+    is_ready().await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn can_create_artifact() -> anyhow::Result<()> {
+    setup().await?;
+    anyhow::bail!("failed one");
+    Ok(())
+}
+
+#[tokio::test]
+async fn can_more_create_artifact() -> anyhow::Result<()> {
+    setup().await?;
+
+    anyhow::bail!("failed two");
+    Ok(())
+}