Refactoring tests.

.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.wasm32-unknown-unknown]
+runner = 'wasm-bindgen-test-runner'

Cargo.toml

@@ -39,7 +39,6 @@ gloo-utils = { version = "0.2", features = ["serde"] }
 wasm-bindgen = "0.2"
 wee_alloc = { version = "0.4.5", optional = true }
 
-
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 js-sys = "0.3"
 wasm-bindgen-test = "0.3.0"

justfile

@@ -31,12 +31,10 @@ fmt-check:
 clippy:
  cargo clippy -- -D warnings
 
-test: build fmt-check clippy test-lib test-unit test-integration test-wasm-node test-wasm-chrome test-wasm-firefox
+test: build fmt-check clippy test-lib test-integration test-wasm-node test-wasm-chrome test-wasm-firefox
 
 test-lib:
  cargo test --lib
-test-unit:
- cargo test --test unit_tests
 test-integration:
  cargo test --test integration_tests
 test-wasm-firefox:

src/lib.rs

@@ -29,7 +29,6 @@ pub struct TranspileOptions {
  pub format: TargetFormat,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub fn from_path(filename: &str, options: TranspileOptions) -> Result<String> {
  let collection = std::fs::read_to_string(filename)?;
  from_str(&collection, options)
@@ -46,6 +45,18 @@ pub fn from_str(collection: &str, options: TranspileOptions) -> Result<String> {
  Ok(oas_definition)
 }
 
+#[cfg(target_arch = "wasm32")]
+pub fn from_str(collection: &str, options: TranspileOptions) -> Result<String> {
+ let postman_spec: postman::Spec = serde_json::from_str(collection)?;
+ let oas_spec = Transpiler::transpile(postman_spec);
+ match options.format {
+ TargetFormat::Json => openapi::to_json(&oas_spec).map_err(|err| err.into()),
+ TargetFormat::Yaml => Err(anyhow::anyhow!(
+ "YAML is not supported for WebAssembly. Please convert from YAML to JSON."
+ )),
+ }
+}
+
 // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
 // allocator.
 #[cfg(feature = "wee_alloc")]
@@ -100,6 +111,10 @@ struct TranspileState<'a> {
 }
 
 impl<'a> Transpiler<'a> {
+ pub fn new(variable_map: &'a BTreeMap<String, serde_json::value::Value>) -> Self {
+ Self { variable_map }
+ }
+
  pub fn transpile(spec: postman::Spec) -> openapi::OpenApi {
  let description = extract_description(&spec.info.description);
 
@@ -700,11 +715,11 @@ impl<'a> Transpiler<'a> {
  value: Some(example_val),
  };
 
- if let openapi3::MediaTypeExample::Examples { examples: ex } = examples {
-  let mut ex2 = ex.clone();
- ex2.insert(name.to_string(), ObjectOrReference::Object(example));
+ if let openapi3::MediaTypeExample::Examples { examples: mut ex } = examples
+ {
+ ex.insert(name.to_string(), ObjectOrReference::Object(example));
  content.examples =
- Some(openapi3::MediaTypeExample::Examples { examples: ex2 });
+ Some(openapi3::MediaTypeExample::Examples { examples: ex });
  }
  *content = content.clone();
  }
@@ -746,11 +761,11 @@ impl<'a> Transpiler<'a> {
  value: Some(oas_obj),
  };
 
- if let openapi3::MediaTypeExample::Examples { examples: ex } = examples {
-  let mut ex2 = ex.clone();
- ex2.insert(name.to_string(), ObjectOrReference::Object(example));
+ if let openapi3::MediaTypeExample::Examples { examples: mut ex } = examples
+ {
+ ex.insert(name.to_string(), ObjectOrReference::Object(example));
  content.examples =
- Some(openapi3::MediaTypeExample::Examples { examples: ex2 });
+ Some(openapi3::MediaTypeExample::Examples { examples: ex });
  }
  }
  }
@@ -1161,3 +1176,235 @@ fn extract_description(description: &Option<postman::DescriptionUnion>) -> Optio
  None => None,
  }
 }
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use openapi::v3_0::{MediaTypeExample, ObjectOrReference, Parameter, Schema};
+ use openapi::OpenApi;
+ use postman::Spec;
+
+ #[test]
+ fn test_extract_description() {
+ let description = Some(postman::DescriptionUnion::String("test".to_string()));
+ assert_eq!(extract_description(&description), Some("test".to_string()));
+
+ let description = Some(postman::DescriptionUnion::Description(
+ postman::Description {
+ content: Some("test".to_string()),
+ ..postman::Description::default()
+ },
+ ));
+ assert_eq!(extract_description(&description), Some("test".to_string()));
+
+ let description = None;
+ assert_eq!(extract_description(&description), None);
+ }
+
+ #[test]
+ fn test_generate_path_parameters() {
+ let empty_map = BTreeMap::<_, _>::new();
+ let transpiler = Transpiler::new(&empty_map);
+ let postman_variables = Some(vec![postman::Variable {
+ key: Some("test".to_string()),
+ value: Some(serde_json::Value::String("test_value".to_string())),
+ description: None,
+ ..postman::Variable::default()
+ }]);
+ let path_params = ["/test/".to_string(), "{{test_value}}".to_string()];
+ let params = transpiler.generate_path_parameters(&path_params, &postman_variables);
+ assert_eq!(params.unwrap().len(), 1);
+ }
+
+ #[test]
+ fn test_generate_query_parameters() {
+ let empty_map = BTreeMap::<_, _>::new();
+ let transpiler = Transpiler::new(&empty_map);
+ let query_params = vec![postman::QueryParam {
+ key: Some("test".to_string()),
+ value: Some("{{test}}".to_string()),
+ description: None,
+ ..postman::QueryParam::default()
+ }];
+ let params = transpiler.generate_query_parameters(&query_params);
+ assert_eq!(params.unwrap().len(), 1);
+ }
+
+ #[test]
+ fn it_preserves_order_on_paths() {
+ let spec: Spec = serde_json::from_str(get_fixture("echo.postman.json").as_ref()).unwrap();
+ let oas = Transpiler::transpile(spec);
+ let ordered_paths = [
+ "/get",
+ "/post",
+ "/put",
+ "/patch",
+ "/delete",
+ "/headers",
+ "/response-headers",
+ "/basic-auth",
+ "/digest-auth",
+ "/auth/hawk",
+ "/oauth1",
+ "/cookies/set",
+ "/cookies",
+ "/cookies/delete",
+ "/status/200",
+ "/stream/5",
+ "/delay/2",
+ "/encoding/utf8",
+ "/gzip",
+ "/deflate",
+ "/ip",
+ "/time/now",
+ "/time/valid",
+ "/time/format",
+ "/time/unit",
+ "/time/add",
+ "/time/subtract",
+ "/time/start",
+ "/time/object",
+ "/time/before",
+ "/time/after",
+ "/time/between",
+ "/time/leap",
+ "/transform/collection",
+ "/{method}/hello",
+ ];
+ let OpenApi::V3_0(s) = oas;
+ let keys = s.paths.keys().enumerate();
+ for (i, k) in keys {
+ assert_eq!(k, ordered_paths[i])
+ }
+ }
+
+ #[test]
+ fn it_uses_the_correct_content_type_for_form_urlencoded_data() {
+ let spec: Spec = serde_json::from_str(get_fixture("echo.postman.json").as_ref()).unwrap();
+ let oas = Transpiler::transpile(spec);
+ match oas {
+ OpenApi::V3_0(oas) => {
+ let b = oas
+ .paths
+ .get("/post")
+ .unwrap()
+ .post
+ .as_ref()
+ .unwrap()
+ .request_body
+ .as_ref()
+ .unwrap();
+ if let ObjectOrReference::Object(b) = b {
+ assert!(b.content.contains_key("application/x-www-form-urlencoded"));
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn it_generates_headers_from_the_request() {
+ let spec: Spec = serde_json::from_str(get_fixture("echo.postman.json").as_ref()).unwrap();
+ let oas = Transpiler::transpile(spec);
+ match oas {
+ OpenApi::V3_0(oas) => {
+ let params = oas
+ .paths
+ .get("/headers")
+ .unwrap()
+ .get
+ .as_ref()
+ .unwrap()
+ .parameters
+ .as_ref()
+ .unwrap();
+ let header = params
+ .iter()
+ .find(|p| {
+ if let ObjectOrReference::Object(p) = p {
+ p.location == "header"
+ } else {
+ false
+ }
+ })
+ .unwrap();
+ let expected = ObjectOrReference::Object(Parameter {
+ name: "my-sample-header".to_owned(),
+ location: "header".to_owned(),
+ description: Some("My Sample Header".to_owned()),
+ schema: Some(Schema {
+ schema_type: Some("string".to_owned()),
+ example: Some(serde_json::Value::String(
+ "Lorem ipsum dolor sit amet".to_owned(),
+ )),
+ ..Schema::default()
+ }),
+ ..Parameter::default()
+ });
+ assert_eq!(header, &expected);
+ }
+ }
+ }
+
+ #[test]
+ fn it_generates_root_path_when_no_path_exists_in_collection() {
+ let spec: Spec =
+ serde_json::from_str(get_fixture("only-root-path.postman.json").as_ref()).unwrap();
+ let oas = Transpiler::transpile(spec);
+ match oas {
+ OpenApi::V3_0(oas) => {
+ assert!(oas.paths.contains_key("/"));
+ }
+ }
+ }
+
+ #[test]
+ fn it_parses_graphql_request_bodies() {
+ let spec: Spec =
+ serde_json::from_str(get_fixture("graphql.postman.json").as_ref()).unwrap();
+ let oas = Transpiler::transpile(spec);
+ match oas {
+ OpenApi::V3_0(oas) => {
+ let body = oas
+ .paths
+ .get("/")
+ .unwrap()
+ .post
+ .as_ref()
+ .unwrap()
+ .request_body
+ .as_ref()
+ .unwrap();
+
+ if let ObjectOrReference::Object(body) = body {
+ assert!(body.content.contains_key("application/json"));
+ let content = body.content.get("application/json").unwrap();
+ let schema = content.schema.as_ref().unwrap();
+ if let ObjectOrReference::Object(schema) = schema {
+ let props = schema.properties.as_ref().unwrap();
+ assert!(props.contains_key("query"));
+ assert!(props.contains_key("variables"));
+ }
+ let examples = content.examples.as_ref().unwrap();
+ if let MediaTypeExample::Example { example } = examples {
+ let example: serde_json::Map<String, serde_json::Value> =
+ serde_json::from_value(example.clone()).unwrap();
+ assert!(example.contains_key("query"));
+ assert!(example.contains_key("variables"));
+ }
+ }
+ }
+ }
+ }
+
+ fn get_fixture(filename: &str) -> String {
+ use std::fs;
+
+ let filename: std::path::PathBuf =
+ [env!("CARGO_MANIFEST_DIR"), "./tests/fixtures/", filename]
+ .iter()
+ .collect();
+ let file = filename.into_os_string().into_string().unwrap();
+ fs::read_to_string(file).unwrap()
+ }
+}

src/openapi/mod.rs

@@ -67,8 +67,8 @@ pub fn to_json(spec: &OpenApi) -> Result<String> {
  Ok(serde_json::to_string_pretty(spec)?)
 }
 
-#[cfg(test)]
 #[cfg(not(target_arch = "wasm32"))]
+#[cfg(test)]
 mod tests {
  use super::*;
  use std::{

src/postman/mod.rs

@@ -194,7 +194,7 @@ pub struct GraphQlBodyClass {
  pub variables: Option<String>,
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
 pub struct QueryParam {
  #[serde(rename = "description")]
  pub description: Option<DescriptionUnion>,
@@ -210,7 +210,7 @@ pub struct QueryParam {
  pub value: Option<String>,
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
 pub struct Description {
  /// The content of the description goes here, as a raw string.
  #[serde(rename = "content")]
@@ -234,7 +234,7 @@ pub struct Description {
 /// Using variables in your Postman requests eliminates the need to duplicate requests, which
 /// can save a lot of time. Variables can be defined, and referenced to from any part of a
 /// request.
-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
 pub struct Variable {
  #[serde(rename = "description")]
  pub description: Option<DescriptionUnion>,