Add test for abacus server start

backend/src/audit_log/audit_log_events.rs

@@ -80,10 +80,6 @@ pub struct AuditLogEvent {
 
 #[cfg(test)]
 impl AuditLogEvent {
-    pub fn time(&self) -> DateTime<Utc> {
-        self.time
-    }
-
     pub fn event(&self) -> &AuditEvent {
         &self.event
     }
@@ -96,10 +92,6 @@ impl AuditLogEvent {
         self.message.as_ref()
     }
 
-    pub fn workstation(&self) -> Option<u32> {
-        self.workstation
-    }
-
     pub fn user_id(&self) -> u32 {
         self.user_id
     }

backend/src/bin/abacus.rs

@@ -35,40 +35,48 @@ struct Args {
     reset_database: bool,
 }
 
-/// Main entry point for the application. Sets up the database, and starts the
-/// API server and in-memory file router on port 8080.
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::builder()
-                .with_default_directive(LevelFilter::INFO.into())
-                .from_env()?,
-        )
-        .init();
-
-    let args = Args::parse();
-    let pool = create_sqlite_pool(&args).await?;
-
+/// Start the API server on the given port, using the given database pool.
+async fn start_server(pool: SqlitePool, port: u16) -> Result<(), Box<dyn Error>> {
     let app = router(pool)?;
 
-    let address = SocketAddr::from((Ipv4Addr::UNSPECIFIED, args.port));
+    let address = SocketAddr::from((Ipv4Addr::UNSPECIFIED, port));
     let listener = TcpListener::bind(&address).await?;
+
     info!("Starting API server on http://{}", listener.local_addr()?);
     let listener = listener.tap_io(|tcp_stream| {
         if let Err(err) = tcp_stream.set_nodelay(true) {
             trace!("failed to set TCP_NODELAY on incoming connection: {err:#}");
         }
     });
+
     axum::serve(
         listener,
         app.into_make_service_with_connect_info::<SocketAddr>(),
     )
     .with_graceful_shutdown(shutdown_signal())
     .await?;
+
     Ok(())
 }
 
+/// Main entry point for the application. Sets up the database, and starts the
+/// API server and in-memory file router on port 8080.
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::INFO.into())
+                .from_env()?,
+        )
+        .init();
+
+    let args = Args::parse();
+    let pool = create_sqlite_pool(&args).await?;
+
+    start_server(pool, args.port).await
+}
+
 /// Create a SQLite database if needed, then connect to it and run migrations.
 /// Return a connection pool.
 async fn create_sqlite_pool(
@@ -123,3 +131,35 @@ async fn shutdown_signal() {
         _ = terminate => {},
     }
 }
+
+#[cfg(test)]
+mod test {
+    use rand::Rng;
+    use sqlx::SqlitePool;
+    use test_log::test;
+
+    use super::start_server;
+
+    pub fn random_port() -> u16 {
+        let mut rng = rand::rng();
+
+        rng.random_range(10_000..30_000)
+    }
+
+    #[test(sqlx::test)]
+    async fn test_abacus_starts(pool: SqlitePool) {
+        let random_port = random_port();
+        let task = tokio::spawn(async move {
+            start_server(pool, random_port).await.unwrap();
+        });
+
+        let result = reqwest::get(format!("http://localhost:{random_port}/api/user/whoami"))
+            .await
+            .unwrap();
+
+        assert_eq!(result.status(), 401);
+
+        task.abort();
+        let _ = task.await;
+    }
+}