Revision control
Copy as Markdown
Other Tools
use serde::{Deserialize, Serialize};
use serde_test::{assert_de_tokens_error, assert_tokens, Configure, Token};
use time::macros::datetime;
use time::serde::timestamp;
use time::OffsetDateTime;
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Test {
#[serde(with = "timestamp")]
dt: OffsetDateTime,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct TestMilliseconds {
#[serde(with = "timestamp::milliseconds")]
dt: OffsetDateTime,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct TestMicroseconds {
#[serde(with = "timestamp::microseconds")]
dt: OffsetDateTime,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct TestNanoseconds {
#[serde(with = "timestamp::nanoseconds")]
dt: OffsetDateTime,
}
#[test]
fn serialize_timestamp() {
let value = Test {
dt: datetime!(2000-01-01 00:00:00 UTC),
};
assert_tokens(
&value.compact(),
&[
Token::Struct {
name: "Test",
len: 1,
},
Token::Str("dt"),
Token::I64(946684800),
Token::StructEnd,
],
);
assert_de_tokens_error::<Test>(
&[
Token::Struct {
name: "Test",
len: 1,
},
Token::Str("dt"),
Token::Str("bad"),
Token::StructEnd,
],
"invalid type: string \"bad\", expected i64",
);
}
#[test]
fn serialize_timestamp_milliseconds() -> serde_json::Result<()> {
let value_milliseconds = TestMilliseconds {
dt: datetime!(2000-01-01 00:00:00.999 UTC),
};
assert_de_tokens_error::<TestMilliseconds>(
&[
Token::Struct {
name: "TestMilliseconds",
len: 1,
},
Token::Str("dt"),
Token::Str("bad"),
Token::StructEnd,
],
"invalid type: string \"bad\", expected i128",
);
// serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
let milliseconds_str = r#"{"dt":946684800999}"#;
let deserialized_milliseconds: TestMilliseconds = serde_json::from_str(milliseconds_str)?;
let serialized_milliseconds = serde_json::to_string(&value_milliseconds)?;
assert_eq!(value_milliseconds.dt, deserialized_milliseconds.dt);
assert_eq!(serialized_milliseconds, milliseconds_str);
Ok(())
}
#[test]
fn serialize_timestamp_microseconds() -> serde_json::Result<()> {
let value_microseconds = TestMicroseconds {
dt: datetime!(2000-01-01 00:00:00.999_999 UTC),
};
assert_de_tokens_error::<TestMicroseconds>(
&[
Token::Struct {
name: "TestMicroseconds",
len: 1,
},
Token::Str("dt"),
Token::Str("bad"),
Token::StructEnd,
],
"invalid type: string \"bad\", expected i128",
);
// serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
let microseconds_str = r#"{"dt":946684800999999}"#;
let deserialized_microseconds: TestMicroseconds = serde_json::from_str(microseconds_str)?;
let serialized_microseconds = serde_json::to_string(&value_microseconds)?;
assert_eq!(value_microseconds.dt, deserialized_microseconds.dt);
assert_eq!(serialized_microseconds, microseconds_str);
Ok(())
}
#[test]
fn serialize_timestamp_nanoseconds() -> serde_json::Result<()> {
let value_nanoseconds = TestNanoseconds {
dt: datetime!(2000-01-01 00:00:00.999_999_999 UTC),
};
assert_de_tokens_error::<TestNanoseconds>(
&[
Token::Struct {
name: "TestNanoseconds",
len: 1,
},
Token::Str("dt"),
Token::Str("bad"),
Token::StructEnd,
],
"invalid type: string \"bad\", expected i128",
);
// serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
let nanoseconds_str = r#"{"dt":946684800999999999}"#;
let deserialized_nanoseconds: TestNanoseconds = serde_json::from_str(nanoseconds_str)?;
let serialized_nanoseconds = serde_json::to_string(&value_nanoseconds)?;
assert_eq!(value_nanoseconds.dt, deserialized_nanoseconds.dt);
assert_eq!(serialized_nanoseconds, nanoseconds_str);
Ok(())
}