vendor/semver-0.10.0/tests/serde.rs

   1 #![cfg(feature = "serde")]
   2
   3 #[macro_use]
   4 extern crate serde_derive;
   5
   6 extern crate semver;
   7 extern crate serde_json;
   8
   9 use semver::{Identifier, Version, VersionReq};
  10
  11 #[derive(Serialize, Deserialize, PartialEq, Debug)]
  12 struct Identified {
  13     name: String,
  14     identifier: Identifier,
  15 }
  16
  17 #[derive(Serialize, Deserialize, PartialEq, Debug)]
  18 struct Versioned {
  19     name: String,
  20     vers: Version,
  21 }
  22
  23 #[test]
  24 fn serialize_identifier() {
  25     let id = Identified {
  26         name: "serde".to_owned(),
  27         identifier: Identifier::Numeric(100),
  28     };
  29     let j = serde_json::to_string(&id).unwrap();
  30     assert_eq!(j, r#"{"name":"serde","identifier":100}"#);
  31
  32     let id = Identified {
  33         name: "serde".to_owned(),
  34         identifier: Identifier::AlphaNumeric("b100".to_owned()),
  35     };
  36     let j = serde_json::to_string(&id).unwrap();
  37     assert_eq!(j, r#"{"name":"serde","identifier":"b100"}"#);
  38 }
  39
  40 #[test]
  41 fn deserialize_identifier() {
  42     let j = r#"{"name":"serde","identifier":100}"#;
  43     let id = serde_json::from_str::<Identified>(j).unwrap();
  44     let expected = Identified {
  45         name: "serde".to_owned(),
  46         identifier: Identifier::Numeric(100),
  47     };
  48     assert_eq!(id, expected);
  49
  50     let j = r#"{"name":"serde","identifier":"b100"}"#;
  51     let id = serde_json::from_str::<Identified>(j).unwrap();
  52     let expected = Identified {
  53         name: "serde".to_owned(),
  54         identifier: Identifier::AlphaNumeric("b100".to_owned()),
  55     };
  56     assert_eq!(id, expected);
  57 }
  58
  59 #[test]
  60 fn serialize_version() {
  61     let v = Versioned {
  62         name: "serde".to_owned(),
  63         vers: Version::parse("1.0.0").unwrap(),
  64     };
  65     let j = serde_json::to_string(&v).unwrap();
  66     assert_eq!(j, r#"{"name":"serde","vers":"1.0.0"}"#);
  67 }
  68
  69 #[test]
  70 fn deserialize_version() {
  71     let j = r#"{"name":"serde","vers":"1.0.0"}"#;
  72     let v = serde_json::from_str::<Versioned>(j).unwrap();
  73     let expected = Versioned {
  74         name: "serde".to_owned(),
  75         vers: Version::parse("1.0.0").unwrap(),
  76     };
  77     assert_eq!(v, expected);
  78 }
  79
  80 #[test]
  81 fn serialize_versionreq() {
  82     let v = VersionReq::exact(&Version::parse("1.0.0").unwrap());
  83
  84     assert_eq!(serde_json::to_string(&v).unwrap(), r#""= 1.0.0""#);
  85 }
  86
  87 #[test]
  88 fn deserialize_versionreq() {
  89     assert_eq!(
  90         "1.0.0".parse::<VersionReq>().unwrap(),
  91         serde_json::from_str(r#""1.0.0""#).unwrap()
  92     );
  93 }