Fastly/WASM Support

- adds plumbing to run fastly depended specs via viceroy
- swaps from using feature flags to using architecture cfg flags
  - these play nicer with nextest
  - also allows us to exclude httpmock from the dev deps if we are
    targeting wasm as httpmock does not support wasm
- updates existing unit tests to be cfg flagged
  - excludes them from compilation if the target is wasm
  - im sorry but i could not find another way to accomplish this

Author: aturingmachine

.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.wasm32-wasip1]
+runner = "viceroy run -C fastly.unit-test.toml -- "

.cargo/nextest.toml

@@ -0,0 +1,2 @@
+[profile.default]
+platform = { target_arch = "wasm32" }

Cargo.toml

@@ -26,14 +26,20 @@ flume = "0.10.14"
 
 flagsmith-flag-engine = "0.4.0"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+reqwest = { version = "0.11", features = ["json", "blocking"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
 reqwest = { version = "0.11", features = ["json"] }
-fastly = { version = "^0.11.5", optional = true }
+fastly = { version = "^0.11.5" }
 
 [dev-dependencies]
-httpmock = "0.6"
 rstest = "0.12.0"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+httpmock = "0.6"
+
 [features]
-default = ["blocking"]
-non_blocking = ["fastly"]
-blocking = ["reqwest/blocking"]
+# default = ["blocking"]
+# non_blocking = ["fastly"]
+# blocking = ["reqwest/blocking"]

fastly.unit-test.toml

@@ -0,0 +1,15 @@
+# This file describes a Fastly Compute@Edge package. To learn more visit:
+# https://developer.fastly.com/reference/fastly-toml/
+
+authors = [
+  "Gagan Trivedi <[email protected]>",
+  "Kim Gustyr <[email protected]>",
+]
+description = "Flagsmith Rust Client."
+language = "rust"
+manifest_version = 2
+name = "flagsmith-rust-client"
+service_id = ""
+
+[scripts]
+build = "cargo build --release --target wasm32-wasip1 --color always"

scripts/fastly-unit-test.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+function run-specs() {
+  cargo nextest run --target wasm32-wasip1 flagsmith::client
+}
+
+if [ "$0" = "${BASH_SOURCE[0]}" ]; then
+  set -eo pipefail 
+  run-specs "${@:-}"
+  exit $?
+fi

scripts/test.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+function run-default-tests() {
+  echo "Running default tests"
+  cargo test
+}
+
+function run-fastly-tests() {
+  echo "Running fastly/wasm tests"
+  ./scripts/fastly-unit-test.sh
+}
+
+if [ "$0" = "${BASH_SOURCE[0]}" ]; then
+  set -eo pipefail
+
+  run-default-tests && run-fastly-tests
+
+  exit $?
+fi

src/flagsmith/analytics.rs

@@ -87,7 +87,7 @@ fn flush(client: &SafeClient, analytics_data: &HashMap<String, u32>, analytics_e
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, not(target_arch = "wasm32")))]
 mod tests {
     use super::*;
     use httpmock::prelude::*;

src/flagsmith/client/blocking_client.rs

@@ -32,6 +32,10 @@ impl ResponseStatusCode for reqwest::StatusCode {
     fn is_success(&self) -> bool {
         self.is_success()
     }
+
+    fn as_u16(&self) -> u16 {
+        self.as_u16()
+    }
 }
 
 impl ClientResponse for reqwest::blocking::Response {

src/flagsmith/client/client.rs

@@ -3,9 +3,9 @@ use std::time::Duration;
 use reqwest::header::HeaderMap;
 use serde::de::DeserializeOwned;
 
-#[cfg(not(feature = "non_blocking"))]
+#[cfg(not(target_arch = "wasm32"))]
 use crate::flagsmith::client::blocking_client::BlockingClient;
-#[cfg(feature = "non_blocking")]
+#[cfg(target_arch = "wasm32")]
 use crate::flagsmith::client::fastly_client::FastlyClient;
 
 pub enum Method {
@@ -22,6 +22,10 @@ pub enum Method {
 
 pub trait ResponseStatusCode {
     fn is_success(&self) -> bool;
+
+    /// Exists for Unit Testing purposes
+    #[allow(dead_code)]
+    fn as_u16(&self) -> u16;
 }
 
 pub trait ClientRequestBuilder {
@@ -48,22 +52,22 @@ pub trait ClientLike {
 
 #[derive(Clone)]
 pub struct SafeClient {
-    #[cfg(not(feature = "non_blocking"))]
+    #[cfg(not(target_arch = "wasm32"))]
     pub inner: BlockingClient,
 
-    #[cfg(feature = "non_blocking")]
+    #[cfg(target_arch = "wasm32")]
     pub inner: FastlyClient,
 }
 
 impl SafeClient {
-    #[cfg(not(feature = "non_blocking"))]
+    #[cfg(not(target_arch = "wasm32"))]
     pub fn new(headers: HeaderMap, timeout: Duration) -> Self {
         Self {
             inner: BlockingClient::new(headers, timeout),
         }
     }
 
-    #[cfg(feature = "non_blocking")]
+    #[cfg(target_arch = "wasm32")]
     pub fn new(headers: HeaderMap, timeout: Duration) -> Self {
         Self {
             inner: FastlyClient::new(headers, timeout),

src/flagsmith/client/fastly_client.rs

@@ -32,6 +32,10 @@ impl super::client::ResponseStatusCode for http::StatusCode {
 
         raw >= 200 && raw <= 299
     }
+
+    fn as_u16(&self) -> u16 {
+        self.as_u16()
+    }
 }
 
 impl super::client::ClientResponse for http::Response {
@@ -57,9 +61,9 @@ impl super::client::ClientResponse for http::Response {
 }
 
 /// Wrapper to help with abstraction of the client interface.
-struct FastlyRequestBuilder {
+pub struct FastlyRequestBuilder {
     backend: String,
-    request: Result<http::Request, ()>,
+    pub request: Result<http::Request, ()>,
 }
 
 impl ClientRequestBuilder for FastlyRequestBuilder {
@@ -113,3 +117,64 @@ impl ClientLike for FastlyClient {
         }
     }
 }
+
+#[cfg(all(test, target_arch = "wasm32"))]
+mod tests {
+    use fastly::Response;
+    use serde::{Deserialize, Serialize};
+    use serde_json::json;
+
+    use super::*;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct TestData {
+        key: String,
+    }
+
+    #[test]
+    fn test_status_code_is_success() {
+        let status = http::StatusCode::from_u16(199).unwrap();
+        assert!(!status.is_success());
+
+        let status = http::StatusCode::from_u16(300).unwrap();
+        assert!(!status.is_success());
+
+        for i in 200..=299 {
+            let status = http::StatusCode::from_u16(i).unwrap();
+
+            assert!(status.is_success(), "{} should be success", i);
+        }
+    }
+
+    #[test]
+    fn test_response_status_returns_status() {
+        let resp = Response::from_status(418);
+
+        assert_eq!(resp.status().as_u16(), 418);
+    }
+
+    #[test]
+    fn test_response_text_returns_body() {
+        let resp = Response::from_body("This is a test body.");
+
+        let text = resp.text();
+
+        assert!(text.is_ok());
+        assert_eq!(text.unwrap(), "This is a test body.");
+    }
+
+    #[test]
+    fn test_response_json_returns_body() {
+        let resp = Response::from_body(json!({ "key": "value" }).to_string());
+
+        let result = resp.json::<TestData>();
+
+        assert!(result.is_ok());
+        assert_eq!(
+            result.unwrap(),
+            TestData {
+                key: "value".to_string()
+            }
+        );
+    }
+}