tests: add basic unit tests for compute-static

fix: remame compute-static build target to wasip1
fix: pin toolchain to 1.90 due to https://www.fastlystatus.com/incident/378001
tweak: handle version-downloads URL path with/without trailing slash in the same way without permanent redirects
refactor: move request/response log collection to log_line to facilitate testing

Author: Carbonhell

terragrunt/modules/crates-io/compute-static/.cargo/config.toml

@@ -1,2 +1,5 @@
 [build]
-target = "wasm32-wasi"
+target = "wasm32-wasip1"
+
+[target.wasm32-wasip1]
+runner = "viceroy run -C fastly.toml -- "

terragrunt/modules/crates-io/compute-static/Cargo.lock

@@ -8,13 +8,33 @@ responses.
 
 ## Development
 
-Build the function:
+Install the Fastly CLI from [here](https://www.fastly.com/documentation/reference/tools/cli/#installing).
+
+Then, build the function:
 
 ```shell
 cd compute-static
 fastly compute build
 ```
 
+## Testing
+
+Testing requires [cargo-nextest](https://nexte.st/docs/installation/pre-built-binaries/), as specified in the [Fastly documentation](https://www.fastly.com/documentation/guides/compute/developer-guides/rust/). You can install it from source with binstall:
+```shell
+cargo install cargo-binstall
+cargo binstall cargo-nextest --secure
+```
+
+Then, install [Viceroy](https://github.com/fastly/Viceroy) to run the edge function locally:
+```shell
+cargo install --locked viceroy
+```
+
+Now you can run the tests with:
+```shell
+cargo nextest run
+```
+
 ## Deployment
 
 Terraform uses an [external data source] to build the function as part of its

terragrunt/modules/crates-io/compute-static/README.md

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "stable"
+channel = "1.90"
 targets = ["wasm32-wasip1"]

terragrunt/modules/crates-io/compute-static/rust-toolchain.toml

@@ -1,9 +1,16 @@
+use std::env::var;
 use std::net::IpAddr;
 
+use crate::config::Config;
+use crate::http_version_to_string;
 use derive_builder::Builder;
+use fastly::{Error, Request, Response};
 use serde::Serialize;
 use time::OffsetDateTime;
 
+const DATADOG_APP: &str = "crates.io";
+const DATADOG_SERVICE: &str = "static.crates.io";
+
 #[derive(Debug, Serialize)]
 #[serde(tag = "version")]
 pub enum LogLine {
@@ -33,6 +40,65 @@ pub struct LogLineV1 {
     url: String,
 }
 
+impl LogLineV1 {
+    /// Collect data for the logs from the request
+    pub fn collect_request(config: &Config, request: &Request) -> LogLineV1Builder {
+        let http_details = HttpDetailsBuilder::default()
+            .protocol(http_version_to_string(request.get_version()))
+            .referer(
+                request
+                    .get_header("Referer")
+                    .and_then(|s| s.to_str().ok())
+                    .map(|s| s.to_string()),
+            )
+            .useragent(
+                request
+                    .get_header("User-Agent")
+                    .and_then(|s| s.to_str().ok())
+                    .map(|s| s.to_string()),
+            )
+            .build()
+            .ok();
+
+        let tls_details = TlsDetailsBuilder::default()
+            .cipher(request.get_tls_cipher_openssl_name())
+            .protocol(request.get_tls_protocol())
+            .build()
+            .ok();
+
+        let log_line = LogLineV1Builder::default()
+            .ddtags(format!("app:{},env:{}", DATADOG_APP, config.datadog_env))
+            .service(DATADOG_SERVICE)
+            .date_time(OffsetDateTime::now_utc())
+            .edge_location(var("FASTLY_POP").ok())
+            .host(request.get_url().host().map(|s| s.to_string()))
+            .http(http_details)
+            .ip(request.get_client_ip_addr())
+            .method(Some(request.get_method().to_string()))
+            .url(request.get_url_str().into())
+            .tls(tls_details)
+            .to_owned();
+
+        log_line
+    }
+
+    /// Collect data for the logs from the response
+    pub fn collect_response(
+        log_line: &mut LogLineV1Builder,
+        response: &Result<Response, Error>,
+    ) -> LogLineV1Builder {
+        if let Ok(response) = response {
+            log_line
+                .bytes(response.get_content_length())
+                .content_type(response.get_content_type().map(|s| s.to_string()))
+                .status(Some(response.get_status().as_u16()))
+                .to_owned()
+        } else {
+            log_line.status(Some(500)).to_owned()
+        }
+    }
+}
+
 fn default_source() -> &'static str {
     "fastly"
 }
@@ -49,3 +115,43 @@ pub struct TlsDetails {
     cipher: Option<&'static str>,
     protocol: Option<&'static str>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Verifies whether the log collector can correctly build a log line from a request/response pair.
+    #[test]
+    fn test_log_collector() {
+        let client_req = Request::get("https://crates.io/crates/syn"); // Arbitrary crate with no meaning
+        let config = Config {
+            primary_host: "test_backend".to_string(),
+            fallback_host: "fallback_host".to_string(),
+            static_ttl: 0,
+            cloudfront_url: "cloudfront_url".to_string(),
+            datadog_env: "datadog_env".to_string(),
+            datadog_host: "datadog_host".to_string(),
+            datadog_request_logs_endpoint: "datadog_request_logs_endpoint".to_string(),
+            s3_request_logs_endpoint: "s3_request_logs_endpoint".to_string(),
+            s3_service_logs_endpoint: "s3_service_logs_endpoint".to_string(),
+        };
+        let mut log = LogLineV1::collect_request(&config, &client_req);
+        let log = LogLineV1::collect_response(
+            &mut log,
+            &Ok(Response::temporary_redirect("https://crates.io/")),
+        );
+        let log = log.build().unwrap();
+        assert_eq!(log.ddsource, "fastly");
+        assert_eq!(
+            log.ddtags,
+            format!("app:crates.io,env:{}", config.datadog_env)
+        );
+        assert_eq!(log.service, "static.crates.io");
+        assert_eq!(
+            log.host,
+            Some(client_req.get_url().host().unwrap().to_string())
+        );
+        assert_eq!(log.url, client_req.get_url_str());
+        assert_eq!(log.method, Some(client_req.get_method().to_string()));
+    }
+}