fix(resource-recorder, provisioner): fix integration tests

common-tests/src/lib.rs

@@ -55,12 +55,14 @@ where
     }
 
     fn call(&mut self, mut req: hyper::Request<hyper::Body>) -> Self::Future {
-        req.extensions_mut().insert(Claim::new(
-            "test".to_string(),
+        let mut c = Claim::new(
+            "user-1".to_string(),
             self.scopes.clone(),
             Default::default(),
             AccountTier::default(),
-        ));
+        );
+        c.token = Some("user-1".to_string());
+        req.extensions_mut().insert(c);
         self.inner.call(req)
     }
 }

common/src/backends/client/gateway.rs

@@ -142,13 +142,13 @@ mod tests {
             res,
             vec![
                 Response {
-                    id: "id1".to_string(),
+                    id: "00000000000000000000000001".to_string(),
                     name: "user-1-project-1".to_string(),
                     state: State::Stopped,
                     idle_minutes: Some(30)
                 },
                 Response {
-                    id: "id2".to_string(),
+                    id: "00000000000000000000000002".to_string(),
                     name: "user-1-project-2".to_string(),
                     state: State::Ready,
                     idle_minutes: Some(30)
@@ -162,6 +162,6 @@ mod tests {
     async fn get_user_project_ids(client: &mut Client) {
         let res = client.get_user_project_ids("user-2").await.unwrap();
 
-        assert_eq!(res, vec!["id3"])
+        assert_eq!(res, vec!["00000000000000000000000003"])
     }
 }

common/src/test_utils.rs

@@ -1,7 +1,7 @@
 use serde::Serialize;
 use wiremock::{
     http,
-    matchers::{method, path},
+    matchers::{method, path, path_regex},
     Mock, MockServer, Request, ResponseTemplate,
 };
 
@@ -10,28 +10,29 @@ pub async fn get_mocked_gateway_server() -> MockServer {
 
     let projects = vec![
         Project {
-            id: "id1",
+            id: "00000000000000000000000001",
             account_id: "user-1",
             name: "user-1-project-1",
             state: "stopped",
             idle_minutes: 30,
         },
         Project {
-            id: "id2",
+            id: "00000000000000000000000002",
             account_id: "user-1",
             name: "user-1-project-2",
             state: "ready",
             idle_minutes: 30,
         },
         Project {
-            id: "id3",
+            id: "00000000000000000000000003",
             account_id: "user-2",
             name: "user-2-project-1",
             state: "ready",
             idle_minutes: 30,
         },
     ];
 
+    let p = projects.clone();
     Mock::given(method(http::Method::GET))
         .and(path("/projects"))
         .respond_with(move |req: &Request| {
@@ -41,18 +42,38 @@ pub async fn get_mocked_gateway_server() -> MockServer {
 
             let user = bearer.to_str().unwrap().split_whitespace().nth(1).unwrap();
 
-            let body: Vec<_> = projects.iter().filter(|p| p.account_id == user).collect();
+            let body: Vec<_> = p.iter().filter(|p| p.account_id == user).collect();
 
             ResponseTemplate::new(200).set_body_json(body)
         })
         .mount(&mock_server)
         .await;
 
+    let p = projects.clone();
+    Mock::given(method(http::Method::HEAD))
+        .and(path_regex("/projects/[a-z0-9-]+"))
+        .respond_with(move |req: &Request| {
+            let Some(bearer) = req.headers.get("AUTHORIZATION") else {
+                return ResponseTemplate::new(401);
+            };
+            let project = req.url.path().strip_prefix("/projects/").unwrap();
+
+            let user = bearer.to_str().unwrap().split_whitespace().nth(1).unwrap();
+
+            if p.iter().any(|p| p.account_id == user && p.name == project) {
+                ResponseTemplate::new(200)
+            } else {
+                ResponseTemplate::new(401)
+            }
+        })
+        .mount(&mock_server)
+        .await;
+
     mock_server
 }
 
 /// A denormalized project to make it easy to return mocked responses
-#[derive(Serialize)]
+#[derive(Debug, Clone, Serialize)]
 struct Project<'a> {
     id: &'a str,
     account_id: &'a str,

provisioner/tests/provisioner.rs

@@ -69,8 +69,8 @@ mod needs_docker {
         let mut r_r_client = resource_recorder::get_client(rr_uri).await;
         r_r_client
             .record_resources(Request::new(RecordRequest {
-                project_id: "id1".to_string(),
-                service_id: "service_id".to_string(),
+                project_id: "00000000000000000000000001".to_string(),
+                service_id: "00000000000000000000000001".to_string(),
                 resources: vec![
                     record_request::Resource {
                         r#type: "database::shared::postgres".to_string(),

resource-recorder/tests/integration.rs

@@ -15,7 +15,6 @@ use shuttle_proto::resource_recorder::{
 use shuttle_resource_recorder::{Service, Sqlite};
 use tokio::select;
 use tonic::{transport::Server, Request};
-use ulid::Ulid;
 
 #[tokio::test]
 async fn manage_resources() {
@@ -48,10 +47,10 @@ async fn manage_resources() {
             .await
             .unwrap();
 
-        let project_id = Ulid::new().to_string();
-        let service_id = "id1".to_string();
+        let project_id = "00000000000000000000000001".to_string();
+        let service_id = "00000000000000000000000001".to_string();
 
-        let mut req = Request::new(RecordRequest {
+        let req = Request::new(RecordRequest {
             project_id: project_id.clone(),
             service_id: service_id.clone(),
             resources: vec![
@@ -67,12 +66,6 @@ async fn manage_resources() {
                 },
             ],
         });
-        req.metadata_mut().insert(
-            "authorization",
-            format!("Bearer user-1")
-                .parse()
-                .expect("to construct a bearer token"),
-        );
 
         // Add resources for on service
         let response = client.record_resources(req).await.unwrap().into_inner();
@@ -85,7 +78,7 @@ async fn manage_resources() {
         assert_eq!(response, expected);
 
         // Add resources for another service on same project
-        let service_id2 = "id2".to_string();
+        let service_id2 = "00000000000000000000000002".to_string();
 
         let response = client
             .record_resources(Request::new(RecordRequest {
@@ -104,8 +97,8 @@ async fn manage_resources() {
         assert_eq!(response, expected);
 
         // Add resources to a new project
-        let project_id2 = Ulid::new().to_string();
-        let service_id3 = "id3".to_string();
+        let project_id2 = "00000000000000000000000002".to_string();
+        let service_id3 = "00000000000000000000000003".to_string();
 
         let response = client
             .record_resources(Request::new(RecordRequest {
@@ -152,11 +145,25 @@ async fn manage_resources() {
             created_at: response.resources[1].created_at.clone(),
             last_updated: response.resources[1].last_updated.clone(),
         };
+        let service_secrets2 = Resource {
+            project_id: project_id.clone(),
+            service_id: service_id2.clone(),
+            r#type: "secrets".to_string(),
+            config: serde_json::to_vec(&json!({"folder": "static"})).unwrap(),
+            data: serde_json::to_vec(&json!({"path": "/tmp/static"})).unwrap(),
+            is_active: true,
+            created_at: response.resources[2].created_at.clone(),
+            last_updated: response.resources[2].last_updated.clone(),
+        };
 
         let expected = ResourcesResponse {
             success: true,
             message: String::new(),
-            resources: vec![service_db.clone(), service_secrets.clone()],
+            resources: vec![
+                service_db.clone(),
+                service_secrets.clone(),
+                service_secrets2,
+            ],
         };
 
         assert_eq!(response, expected);