Function pact_models::pact::parse_meta_data

pub fn parse_meta_data(
    pact_json: &Value
) -> BTreeMap<String, BTreeMap<String, String>>

Construct Metadata from JSON value

Examples found in repository

src/sync_pact.rs (line 168)

  pub fn from_json(file: &str, pact_json: &Value
  ) -> anyhow::Result<RequestResponsePact> {
    let metadata = parse_meta_data(pact_json);
    let spec_version = determine_spec_version(file, &metadata);

    let consumer = match pact_json.get("consumer") {
      Some(v) => Consumer::from_json(v),
      None => Consumer { name: "consumer".to_string() }
    };
    let provider = match pact_json.get("provider") {
      Some(v) => Provider::from_json(v),
      None => Provider { name: "provider".to_string() }
    };
    Ok(RequestResponsePact {
      consumer,
      provider,
      interactions: parse_interactions(pact_json, spec_version.clone())?,
      metadata,
      specification_version: spec_version,
    })
  }

src/pact.rs (line 173)

pub fn load_pact_from_json(source: &str, json: &Value) -> anyhow::Result<Box<dyn Pact + Send + Sync>> {
  match json {
    Value::Object(map) => {
      let metadata = parse_meta_data(json);
      let spec_version = determine_spec_version(source, &metadata);
      trace!("load_pact_from_json: found spec version {} in metadata", spec_version);
      match spec_version {
        PactSpecification::V4 => v4::pact::from_json(&source, json),
        _ => if map.contains_key("messages") {
          trace!("load_pact_from_json: JSON has a messages attribute, will load as a message pact");
          let pact = MessagePact::from_json(source, json)?;
          Ok(Box::new(pact))
        } else {
          trace!("load_pact_from_json: loading JSON as a request/response pact");
          Ok(Box::new(RequestResponsePact::from_json(source, json)?))
        }
      }
    },
    _ => Err(anyhow!("Failed to parse Pact JSON from source '{}' - it is not a valid pact file", source))
  }
}

src/message_pact.rs (line 174)

    pub fn from_json(file: &str, pact_json: &Value) -> anyhow::Result<MessagePact> {
        let metadata = parse_meta_data(pact_json);
        let spec_version = determine_spec_version(file, &metadata);

        let consumer = match pact_json.get("consumer") {
            Some(v) => Consumer::from_json(v),
            None => Consumer { name: "consumer".to_string() }
        };
        let provider = match pact_json.get("provider") {
            Some(v) => Provider::from_json(v),
            None => Provider { name: "provider".to_string() }
        };

        let messages = match pact_json.get("messages") {
            Some(Value::Array(msg_arr)) => {
                let mut messages = Vec::with_capacity(msg_arr.len());
                for (ix, msg) in msg_arr.iter().enumerate() {
                    messages.push(
                        Message::from_json(ix, msg, &spec_version)?
                    );
                }
                messages
            }
            Some(_) => bail!("Expecting 'messages' field to be Array"),
            None => vec![],
        };

        Ok(MessagePact {
            consumer,
            provider,
            messages,
            metadata,
            specification_version: spec_version.clone(),
        })
    }