use std::borrow::Cow;
use std::collections::BTreeMap;
use std::fmt;
use std::num::ParseIntError;
use std::str::FromStr;
use std::time::Duration;
use http::header::{self, HeaderMap, HeaderName};
use serde::{Deserialize, Serialize};
use crate::duration::{ParseDurationError, format_duration, parse_duration};
use crate::headers;
use crate::time::{InvalidTimestamp, Rfc3339Timestamp, Timestamp};
pub const HEADER_EXPIRATION: &str = "x-sn-expiration";
pub const HEADER_TIME_CREATED: &str = "x-sn-time-created";
pub const HEADER_TIME_EXPIRES: &str = "x-sn-time-expires";
pub const HEADER_ORIGIN: &str = "x-sn-origin";
pub const HEADER_FILENAME: &str = "x-sn-filename";
pub const HEADER_SIZE: &str = "x-sn-size";
pub const HEADER_META_PREFIX: &str = "x-snme-";
pub const DEFAULT_CONTENT_TYPE: &str = "application/octet-stream";
const MAX_TTI_DEBOUNCE: Duration = Duration::from_hours(24);
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
pub struct MetadataUpdate {
pub extend_expiry: ExpiryExtension,
}
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(untagged, deny_unknown_fields)]
pub enum ExpiryExtension {
At {
at: Rfc3339Timestamp,
},
After {
#[serde(with = "crate::duration")]
after: Duration,
from: ExpiryAnchor,
},
}
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ExpiryAnchor {
Creation,
Now,
}
#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub struct InvalidContentType(mediatype::MediaTypeError);
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("error dealing with http headers")]
Header(#[from] Option<http::Error>),
#[error("invalid expiration policy value")]
Expiration(#[from] Option<ParseDurationError>),
#[error("invalid compression value")]
Compression,
#[error("invalid content type")]
ContentType(#[from] InvalidContentType),
#[error("invalid creation time")]
CreationTime(#[from] humantime::TimestampError),
#[error("invalid expiration time")]
ExpirationTime(#[from] InvalidTimestamp),
#[error("invalid object size")]
Size(#[from] ParseIntError),
#[error("invalid metadata header value")]
Encoding(#[from] crate::headers::DecodeError),
#[error("invalid custom metadata key {0:?}")]
CustomKey(String),
#[error("invariant violation: {0}")]
Invariant(&'static str),
}
impl From<header::InvalidHeaderValue> for Error {
fn from(err: header::InvalidHeaderValue) -> Self {
Self::Header(Some(err.into()))
}
}
impl From<header::InvalidHeaderName> for Error {
fn from(err: header::InvalidHeaderName) -> Self {
Self::Header(Some(err.into()))
}
}
impl From<header::ToStrError> for Error {
fn from(_err: header::ToStrError) -> Self {
Self::Header(None)
}
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum ExpirationPolicy {
#[default]
Manual,
TimeToLive(Duration),
TimeToIdle(Duration),
}
impl ExpirationPolicy {
pub fn expires_in(&self) -> Option<Duration> {
match self {
ExpirationPolicy::Manual => None,
ExpirationPolicy::TimeToLive(duration) => Some(*duration),
ExpirationPolicy::TimeToIdle(duration) => Some(*duration),
}
}
pub fn is_timeout(&self) -> bool {
match self {
ExpirationPolicy::TimeToLive(_) => true,
ExpirationPolicy::TimeToIdle(_) => true,
ExpirationPolicy::Manual => false,
}
}
pub fn is_manual(&self) -> bool {
*self == ExpirationPolicy::Manual
}
pub fn check_tti_bump(
&self,
time_expires: Option<Timestamp>,
access_time: Timestamp,
) -> Option<Timestamp> {
let ExpirationPolicy::TimeToIdle(tti) = *self else {
return None;
};
let time_expires = time_expires?;
let new_expire_at = access_time.checked_add(tti)?;
let debounce = (tti / 4).min(MAX_TTI_DEBOUNCE);
(new_expire_at.checked_duration_since(time_expires)? > debounce).then_some(new_expire_at)
}
}
impl fmt::Display for ExpirationPolicy {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ExpirationPolicy::TimeToLive(duration) => {
write!(f, "ttl:{}", format_duration(*duration))
}
ExpirationPolicy::TimeToIdle(duration) => {
write!(f, "tti:{}", format_duration(*duration))
}
ExpirationPolicy::Manual => f.write_str("manual"),
}
}
}
impl FromStr for ExpirationPolicy {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if s == "manual" {
return Ok(ExpirationPolicy::Manual);
}
if let Some(duration) = s.strip_prefix("ttl:") {
return Ok(ExpirationPolicy::TimeToLive(parse_duration(duration)?));
}
if let Some(duration) = s.strip_prefix("tti:") {
return Ok(ExpirationPolicy::TimeToIdle(parse_duration(duration)?));
}
Err(Error::Expiration(None))
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum Compression {
Zstd,
Gzip,
}
impl Compression {
pub fn as_str(&self) -> &str {
match self {
Compression::Zstd => "zstd",
Compression::Gzip => "gzip",
}
}
}
impl fmt::Display for Compression {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for Compression {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"zstd" => Ok(Compression::Zstd),
"gzip" => Ok(Compression::Gzip),
_ => Err(Error::Compression),
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct Metadata {
#[serde(skip_serializing_if = "ExpirationPolicy::is_manual")]
pub expiration_policy: ExpirationPolicy,
#[serde(skip_serializing_if = "Option::is_none")]
pub time_created: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub time_expires: Option<Timestamp>,
pub content_type: Cow<'static, str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub compression: Option<Compression>,
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<usize>,
#[serde(skip_serializing_if = "BTreeMap::is_empty")]
pub custom: BTreeMap<String, String>,
}
impl Metadata {
pub fn from_insert_headers(
headers: &HeaderMap,
prefix: &str,
access_time: Timestamp,
) -> Result<Self, Error> {
let mut metadata = Self::parse_headers(headers, prefix, true)?;
metadata.materialize_write_times(access_time)?;
Ok(metadata)
}
fn materialize_write_times(&mut self, access_time: Timestamp) -> Result<(), Error> {
self.time_created = Some(access_time);
self.time_expires = self
.expiration_policy
.expires_in()
.map(|ttl| access_time.checked_add(ttl).ok_or(InvalidTimestamp))
.transpose()?;
Ok(())
}
pub fn validate(&self) -> Result<(), Error> {
if self.expiration_policy.is_timeout() && self.time_expires.is_none() {
return Err(Error::Invariant(
"expiration policy requires a resolved expiration time",
));
}
if self.expiration_policy.is_manual() && self.time_expires.is_some() {
return Err(Error::Invariant(
"manual expiration policy must not have a resolved expiration time",
));
}
Ok(())
}
pub fn is_expired(&self, access_time: Timestamp) -> bool {
self.time_expires
.is_some_and(|deadline| deadline < access_time)
}
pub fn check_tti_bump(&self, access_time: Timestamp) -> Option<Timestamp> {
self.expiration_policy
.check_tti_bump(self.time_expires, access_time)
}
pub fn from_headers(headers: &HeaderMap, prefix: &str) -> Result<Self, Error> {
Self::parse_headers(headers, prefix, false)
}
fn parse_headers(
headers: &HeaderMap,
prefix: &str,
skip_read_only: bool,
) -> Result<Self, Error> {
let mut metadata = Metadata::default();
for (name, value) in headers {
match *name {
header::CONTENT_TYPE => {
let content_type = value.to_str()?;
validate_content_type(content_type)?;
metadata.content_type = content_type.to_owned().into();
}
header::CONTENT_ENCODING => {
let compression = value.to_str()?;
metadata.compression = Some(Compression::from_str(compression)?);
}
_ => {
let Some(name) = name.as_str().strip_prefix(prefix) else {
continue;
};
match name {
HEADER_EXPIRATION => {
let expiration_policy = value.to_str()?;
metadata.expiration_policy =
ExpirationPolicy::from_str(expiration_policy)?;
}
HEADER_TIME_CREATED if !skip_read_only => {
let timestamp = value.to_str()?;
let time = Timestamp::from_rfc3339(timestamp)?;
metadata.time_created = Some(time);
}
HEADER_TIME_EXPIRES if !skip_read_only => {
let timestamp = value.to_str()?;
let time = Timestamp::from_rfc3339(timestamp)?;
metadata.time_expires = Some(time);
}
HEADER_ORIGIN => {
metadata.origin = Some(headers::decode_header_value(value)?);
}
HEADER_FILENAME => {
metadata.filename = Some(headers::decode_header_value(value)?);
}
HEADER_SIZE if !skip_read_only => {
let size = value.to_str()?;
metadata.size = Some(size.parse()?);
}
_ => {
if let Some(name) = name.strip_prefix(HEADER_META_PREFIX) {
let key = headers::decode_header_str_lossy(name);
let key = if skip_read_only {
normalize_custom_key(&key)?
} else {
key.into_owned()
};
let value = headers::decode_header_value(value)?;
metadata.custom.insert(key, value);
}
}
}
}
}
}
Ok(metadata)
}
pub fn to_headers(&self, prefix: &str) -> Result<HeaderMap, Error> {
let Self {
content_type,
compression,
origin,
filename,
expiration_policy,
time_created,
time_expires,
size,
custom,
} = self;
let mut headers = HeaderMap::new();
headers.append(header::CONTENT_TYPE, content_type.parse()?);
if let Some(compression) = compression {
headers.append(header::CONTENT_ENCODING, compression.as_str().parse()?);
}
if *expiration_policy != ExpirationPolicy::Manual {
let name = HeaderName::try_from(format!("{prefix}{HEADER_EXPIRATION}"))?;
headers.append(name, expiration_policy.to_string().parse()?);
}
if let Some(time) = time_created {
let name = HeaderName::try_from(format!("{prefix}{HEADER_TIME_CREATED}"))?;
let timestamp = time.as_rfc3339();
headers.append(name, timestamp.to_string().parse()?);
}
if let Some(time) = time_expires {
let name = HeaderName::try_from(format!("{prefix}{HEADER_TIME_EXPIRES}"))?;
let timestamp = time.as_rfc3339();
headers.append(name, timestamp.to_string().parse()?);
}
if let Some(origin) = origin {
let name = HeaderName::try_from(format!("{prefix}{HEADER_ORIGIN}"))?;
headers.append(name, headers::encode_header_value(origin));
}
if let Some(filename) = filename {
let name = HeaderName::try_from(format!("{prefix}{HEADER_FILENAME}"))?;
headers.append(name, headers::encode_header_value(filename));
}
if let Some(size) = size {
let name = HeaderName::try_from(format!("{prefix}{HEADER_SIZE}"))?;
headers.append(name, size.to_string().parse()?);
}
for (key, value) in custom {
let key = encode_custom_key(key);
let name = HeaderName::try_from(format!("{prefix}{HEADER_META_PREFIX}{key}"))?;
headers.append(name, headers::encode_header_value(value));
}
Ok(headers)
}
}
pub fn normalize_custom_key(key: &str) -> Result<String, Error> {
let is_allowed = |ch: char| {
ch.is_ascii_alphanumeric()
|| matches!(
ch,
'_' | '-' | '|' | '~' | '%' | '$' | '#' | '+' | '.' | ':'
)
};
if key.is_empty() || !key.chars().all(is_allowed) {
return Err(Error::CustomKey(key.to_owned()));
}
Ok(key.to_ascii_lowercase())
}
pub fn encode_custom_key(key: &str) -> Cow<'_, str> {
if !key.contains(['%', ':']) {
return Cow::Borrowed(key);
}
let mut encoded = String::with_capacity(key.len() + 4);
for ch in key.chars() {
match ch {
'%' => encoded.push_str("%25"),
':' => encoded.push_str("%3a"),
other => encoded.push(other),
}
}
Cow::Owned(encoded)
}
fn validate_content_type(content_type: &str) -> Result<(), Error> {
mediatype::MediaType::parse(content_type).map_err(InvalidContentType)?;
Ok(())
}
impl Default for Metadata {
fn default() -> Self {
Self {
expiration_policy: ExpirationPolicy::Manual,
time_created: None,
time_expires: None,
content_type: DEFAULT_CONTENT_TYPE.into(),
compression: None,
origin: None,
filename: None,
size: None,
custom: BTreeMap::new(),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
#[non_exhaustive]
pub struct WriteMetadata {
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub content_encoding: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(skip_serializing_if = "BTreeMap::is_empty")]
pub custom: BTreeMap<String, String>,
}
impl WriteMetadata {
pub fn into_metadata(self, access_time: Timestamp) -> Result<Metadata, Error> {
if let Some(content_type) = &self.content_type {
validate_content_type(content_type)?;
}
let custom = self
.custom
.into_iter()
.map(|(key, value)| Ok((normalize_custom_key(&key)?, value)))
.collect::<Result<_, Error>>()?;
let expiration_policy = self.expiration.as_deref().map(str::parse).transpose()?;
let mut metadata = Metadata {
expiration_policy: expiration_policy.unwrap_or_default(),
content_type: self
.content_type
.map_or(DEFAULT_CONTENT_TYPE.into(), Into::into),
compression: self
.content_encoding
.as_deref()
.map(str::parse)
.transpose()?,
origin: self.origin,
filename: self.filename,
custom,
..Default::default()
};
metadata.materialize_write_times(access_time)?;
Ok(metadata)
}
}
impl From<Metadata> for WriteMetadata {
fn from(metadata: Metadata) -> Self {
Self {
content_type: (metadata.content_type != DEFAULT_CONTENT_TYPE)
.then(|| metadata.content_type.into_owned()),
content_encoding: metadata.compression.map(|c| c.to_string()),
expiration: (!metadata.expiration_policy.is_manual())
.then(|| metadata.expiration_policy.to_string()),
origin: metadata.origin,
filename: metadata.filename,
custom: metadata.custom,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReadMetadata {
pub content_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub content_encoding: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub custom: BTreeMap<String, String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub time_created: Option<Rfc3339Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub time_expires: Option<Rfc3339Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<usize>,
}
impl From<Metadata> for ReadMetadata {
fn from(metadata: Metadata) -> Self {
Self {
content_type: metadata.content_type.into_owned(),
content_encoding: metadata.compression.map(|c| c.to_string()),
expiration: (!metadata.expiration_policy.is_manual())
.then(|| metadata.expiration_policy.to_string()),
origin: metadata.origin,
filename: metadata.filename,
custom: metadata.custom,
time_created: metadata.time_created.map(Timestamp::as_rfc3339),
time_expires: metadata.time_expires.map(Timestamp::as_rfc3339),
size: metadata.size,
}
}
}
impl TryFrom<ReadMetadata> for Metadata {
type Error = Error;
fn try_from(object: ReadMetadata) -> Result<Self, Error> {
let expiration_policy = object.expiration.as_deref().map(str::parse).transpose()?;
Ok(Self {
expiration_policy: expiration_policy.unwrap_or_default(),
time_created: object.time_created.map(Rfc3339Timestamp::into_inner),
time_expires: object.time_expires.map(Rfc3339Timestamp::into_inner),
content_type: object.content_type.into(),
compression: object
.content_encoding
.as_deref()
.map(str::parse)
.transpose()?,
origin: object.origin,
filename: object.filename,
size: object.size,
custom: object.custom,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn metadata_update_parses_supported_expiry_extensions() {
let cases = [
(
r#"{"extend_expiry":{"at":"2026-10-16T12:00:00Z"}}"#,
ExpiryExtension::At {
at: "2026-10-16T12:00:00Z".parse().unwrap(),
},
),
(
r#"{"extend_expiry":{"after":"30d","from":"creation"}}"#,
ExpiryExtension::After {
after: Duration::from_secs(30 * 86400),
from: ExpiryAnchor::Creation,
},
),
(
r#"{"extend_expiry":{"after":"0s","from":"now"}}"#,
ExpiryExtension::After {
after: Duration::ZERO,
from: ExpiryAnchor::Now,
},
),
];
for (json, expected) in cases {
let update: MetadataUpdate = serde_json::from_str(json).unwrap();
assert_eq!(update.extend_expiry, expected);
assert_eq!(serde_json::to_string(&update).unwrap(), json);
}
}
#[test]
fn metadata_update_rejects_invalid_structures() {
let cases = [
r#"{"extend_expiry":{"at":"not a timestamp"}}"#,
r#"{"extend_expiry":{"after":"not a duration","from":"now"}}"#,
r#"{}"#,
r#"{"extend_expiry":null}"#,
r#"{"extend_expiry":{}}"#,
r#"{"extend_expiry":{"at":"2026-10-16T12:00:00Z","after":"30d","from":"now"}}"#,
r#"{"extend_expiry":{"after":"30d"}}"#,
r#"{"extend_expiry":{"after":"30d","from":"unsupported"}}"#,
r#"{"extend_expiry":{"at":"2026-10-16T12:00:00Z","unknown":true}}"#,
r#"{"extend_expiry":{"after":"30d","from":"now","unknown":true}}"#,
r#"{"extend_expiry":{"at":"2026-10-16T12:00:00Z"},"content_type":"text/plain"}"#,
];
for json in cases {
assert!(
serde_json::from_str::<MetadataUpdate>(json).is_err(),
"unexpectedly accepted {json}"
);
}
}
#[test]
fn from_headers_with_origin() {
let mut headers = HeaderMap::new();
headers.insert("content-type", "text/plain".parse().unwrap());
headers.insert(HEADER_ORIGIN, "203.0.113.42".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(metadata.origin.as_deref(), Some("203.0.113.42"));
assert_eq!(metadata.content_type, "text/plain");
}
#[test]
fn from_headers_without_origin() {
let mut headers = HeaderMap::new();
headers.insert("content-type", "text/plain".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert!(metadata.origin.is_none());
}
#[test]
fn to_headers_with_origin() {
let metadata = Metadata {
origin: Some("203.0.113.42".into()),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
assert_eq!(headers.get(HEADER_ORIGIN).unwrap(), "203.0.113.42");
}
#[test]
fn to_headers_without_origin() {
let metadata = Metadata::default();
let headers = metadata.to_headers("").unwrap();
assert!(headers.get(HEADER_ORIGIN).is_none());
}
#[test]
fn origin_header_roundtrip() {
let metadata = Metadata {
origin: Some("203.0.113.42".into()),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
let roundtripped = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(roundtripped.origin, metadata.origin);
}
#[test]
fn from_headers_with_filename() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_FILENAME, "report.pdf".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(metadata.filename.as_deref(), Some("report.pdf"));
}
#[test]
fn from_headers_without_filename() {
let headers = HeaderMap::new();
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert!(metadata.filename.is_none());
}
#[test]
fn to_headers_with_filename() {
let metadata = Metadata {
filename: Some("report.pdf".into()),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
assert_eq!(headers.get(HEADER_FILENAME).unwrap(), "report.pdf");
}
#[test]
fn to_headers_without_filename() {
let metadata = Metadata::default();
let headers = metadata.to_headers("").unwrap();
assert!(headers.get(HEADER_FILENAME).is_none());
}
#[test]
fn filename_header_roundtrip() {
let metadata = Metadata {
filename: Some("report.pdf".into()),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
let roundtripped = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(roundtripped.filename, metadata.filename);
}
#[test]
fn free_form_values_are_escaped_on_the_wire() {
let metadata = Metadata {
origin: Some("Ünknown-源".into()),
filename: Some("réport-📄.pdf".into()),
custom: BTreeMap::from([("release".to_owned(), "100% vérsion-🚀".to_owned())]),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
assert_eq!(
headers.get(HEADER_ORIGIN).unwrap(),
"%C3%9Cnknown-%E6%BA%90"
);
assert_eq!(
headers.get(HEADER_FILENAME).unwrap(),
"r%C3%A9port-%F0%9F%93%84.pdf",
);
assert_eq!(
headers.get(format!("{HEADER_META_PREFIX}release")).unwrap(),
"100%25 v%C3%A9rsion-%F0%9F%9A%80",
);
let roundtripped = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(roundtripped.origin, metadata.origin);
assert_eq!(roundtripped.filename, metadata.filename);
assert_eq!(roundtripped.custom, metadata.custom);
}
#[test]
fn from_headers_content_type_and_encoding() {
let mut headers = HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
headers.insert("content-encoding", "zstd".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(metadata.content_type, "application/json");
assert_eq!(metadata.compression, Some(Compression::Zstd));
}
#[test]
fn from_headers_expiration_policy() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_EXPIRATION, "ttl:30s".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(
metadata.expiration_policy,
ExpirationPolicy::TimeToLive(Duration::from_secs(30))
);
}
#[test]
fn expiration_policy_keeps_long_durations_in_days() {
let ttl = Duration::from_secs(400 * 86400 + 3600);
let policy = ExpirationPolicy::TimeToLive(ttl);
assert_eq!(policy.to_string(), "ttl:400d 1h");
assert_eq!(
policy.to_string().parse::<ExpirationPolicy>().unwrap(),
policy
);
}
#[test]
fn expiration_policy_parses_units_that_are_never_emitted() {
let policy: ExpirationPolicy = "tti:2weeks".parse().unwrap();
assert_eq!(
policy,
ExpirationPolicy::TimeToIdle(Duration::from_secs(14 * 86400))
);
assert_eq!(policy.to_string(), "tti:14d");
}
#[test]
fn from_headers_timestamps() {
let mut headers = HeaderMap::new();
headers.insert(
HEADER_TIME_CREATED,
"2024-01-15T12:00:00.123456Z".parse().unwrap(),
);
headers.insert(
HEADER_TIME_EXPIRES,
"2024-01-16T12:00:00.123456Z".parse().unwrap(),
);
let metadata = Metadata::from_headers(&headers, "").unwrap();
let encoded = metadata.to_headers("").unwrap();
assert_eq!(encoded[HEADER_TIME_CREATED], "2024-01-15T12:00:01Z");
assert_eq!(encoded[HEADER_TIME_EXPIRES], "2024-01-16T12:00:01Z");
let deadline = metadata.time_expires.unwrap();
assert!(!metadata.is_expired(deadline - Duration::from_secs(1)));
assert!(!metadata.is_expired(deadline));
assert!(metadata.is_expired(deadline + Duration::from_secs(1)));
}
#[test]
fn from_insert_headers_ignores_read_only_fields() {
let forged_created = "2024-01-15T12:00:00.000000Z";
let mut headers = HeaderMap::new();
headers.insert("content-type", "text/plain".parse().unwrap());
headers.insert(HEADER_TIME_CREATED, forged_created.parse().unwrap());
headers.insert(
HEADER_TIME_EXPIRES,
"2024-01-16T12:00:00.000000Z".parse().unwrap(),
);
let metadata = Metadata::from_insert_headers(&headers, "", Timestamp::now()).unwrap();
let created = metadata.time_created.unwrap();
assert_ne!(created, Timestamp::from_rfc3339(forged_created).unwrap());
assert!(metadata.time_expires.is_none());
assert!(metadata.size.is_none());
assert_eq!(metadata.content_type, "text/plain");
}
#[test]
fn from_insert_headers_ignores_malformed_read_only_fields() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_TIME_CREATED, "not-a-timestamp".parse().unwrap());
headers.insert(HEADER_TIME_EXPIRES, "not-a-timestamp".parse().unwrap());
let metadata = Metadata::from_insert_headers(&headers, "", Timestamp::now()).unwrap();
assert!(metadata.time_created.is_some());
assert!(metadata.time_expires.is_none());
}
#[test]
fn from_insert_headers_resolves_time_expires_for_ttl() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_EXPIRATION, "ttl:30s".parse().unwrap());
let access_time = Timestamp::UNIX_EPOCH;
let metadata = Metadata::from_insert_headers(&headers, "", access_time).unwrap();
let created = metadata.time_created.unwrap();
assert_eq!(created, access_time);
let expires = metadata.time_expires.unwrap();
assert_eq!(expires, created + Duration::from_secs(30));
}
#[test]
fn from_insert_headers_resolves_time_expires_for_tti() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_EXPIRATION, "tti:1h".parse().unwrap());
let access_time = Timestamp::UNIX_EPOCH;
let metadata = Metadata::from_insert_headers(&headers, "", access_time).unwrap();
let created = metadata.time_created.unwrap();
assert_eq!(created, access_time);
let expires = metadata.time_expires.unwrap();
assert_eq!(expires, created + Duration::from_hours(1));
}
#[test]
fn from_insert_headers_manual_leaves_time_expires_none() {
let headers = HeaderMap::new();
let metadata = Metadata::from_insert_headers(&headers, "", Timestamp::now()).unwrap();
assert_eq!(metadata.expiration_policy, ExpirationPolicy::Manual);
assert!(metadata.time_expires.is_none());
}
#[test]
fn validate_accepts_resolved_timeout() {
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToLive(Duration::from_secs(30)),
time_expires: Some(Timestamp::now() + Duration::from_secs(30)),
..Default::default()
};
assert!(metadata.validate().is_ok());
}
#[test]
fn validate_accepts_manual_without_expiry() {
let metadata = Metadata::default();
assert!(metadata.validate().is_ok());
}
#[test]
fn validate_rejects_timeout_without_expiry() {
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(Duration::from_hours(1)),
time_expires: None,
..Default::default()
};
assert!(matches!(metadata.validate(), Err(Error::Invariant(_))));
}
#[test]
fn from_headers_custom_metadata_with_prefix() {
let mut headers = HeaderMap::new();
let prefix = "x-goog-meta-";
let expiration_header: HeaderName = format!("{prefix}{HEADER_EXPIRATION}").parse().unwrap();
headers.insert(expiration_header, "tti:1h".parse().unwrap());
let custom_header: HeaderName = format!("{prefix}{HEADER_META_PREFIX}my-key")
.parse()
.unwrap();
headers.insert(custom_header, "my-value".parse().unwrap());
let metadata = Metadata::from_headers(&headers, prefix).unwrap();
assert_eq!(
metadata.expiration_policy,
ExpirationPolicy::TimeToIdle(Duration::from_hours(1))
);
assert_eq!(metadata.custom.get("my-key").unwrap(), "my-value");
}
#[test]
fn normalize_custom_key_accepts_allowed_characters_and_lowercases() {
let allowed = "abcdefghijklmnopqrstuvwxyz0123456789_-|~%$#+.:";
for ch in allowed.chars() {
let key = format!("k{ch}k");
assert_eq!(normalize_custom_key(&key).unwrap(), key, "rejected {ch:?}");
}
assert_eq!(normalize_custom_key(allowed).unwrap(), allowed);
assert_eq!(normalize_custom_key("Build_ID:X").unwrap(), "build_id:x");
}
#[test]
fn normalize_custom_key_rejects_empty_and_other_characters() {
let rejected = [
"", "a b", "a\tb", "a!b", "a\"b", "a&b", "a'b", "a(b", "a)b", "a*b", "a,b", "a/b",
"a;b", "a<b", "a=b", "a>b", "a?b", "a@b", "a[b", "a\\b", "a]b", "a^b", "a`b", "a{b",
"a}b", "a\nb", "a\x7fb", "kéy", "键", "k🚀",
];
for key in rejected {
std::assert_matches!(
normalize_custom_key(key),
Err(Error::CustomKey(_)),
"accepted {key:?}"
);
}
}
#[test]
fn custom_key_header_name_encoding_roundtrips() {
assert_eq!(encode_custom_key("plain-key_1"), "plain-key_1");
assert_eq!(encode_custom_key("a:b"), "a%3ab");
assert_eq!(encode_custom_key("a%b"), "a%25b");
assert_eq!(encode_custom_key("a%3ab"), "a%253ab");
std::assert_matches!(encode_custom_key("plain"), Cow::Borrowed(_));
assert_eq!(headers::decode_header_str_lossy("a%3ab"), "a:b");
assert_eq!(headers::decode_header_str_lossy("a%3Ab"), "a:b");
assert_eq!(headers::decode_header_str_lossy("a%61"), "aa");
assert_eq!(headers::decode_header_str_lossy("a%253ab"), "a%3ab");
std::assert_matches!(headers::decode_header_str_lossy("plain"), Cow::Borrowed(_));
for key in ["a:b", "a%b", "a%3ab", "a%253ab", "%:%", "a%25", "x:y%z"] {
assert_eq!(
headers::decode_header_str_lossy(&encode_custom_key(key)),
key
);
}
}
#[test]
fn custom_key_header_name_decoding_is_lenient() {
for literal in ["100%", "a%", "a%3", "a%zz", "a%%b", "%2", "50%off"] {
assert_eq!(headers::decode_header_str_lossy(literal), literal);
}
assert_eq!(headers::decode_header_str_lossy("a%ffb"), "a\u{FFFD}b");
}
#[test]
fn custom_keys_with_colon_and_percent_roundtrip_through_headers() {
let metadata = Metadata {
custom: BTreeMap::from([
("a:b".to_owned(), "colon".to_owned()),
("a%3ab".to_owned(), "encoded-looking".to_owned()),
("100%".to_owned(), "percent".to_owned()),
]),
..Default::default()
};
for prefix in ["", "x-goog-meta-"] {
let headers = metadata.to_headers(prefix).unwrap();
assert_eq!(
headers.get(format!("{prefix}x-snme-a%3ab")).unwrap(),
"colon"
);
assert_eq!(
headers.get(format!("{prefix}x-snme-a%253ab")).unwrap(),
"encoded-looking"
);
let roundtripped = Metadata::from_headers(&headers, prefix).unwrap();
assert_eq!(roundtripped.custom, metadata.custom);
let access_time = Timestamp::from_unix_secs(1_700_000_000).unwrap();
let inserted = Metadata::from_insert_headers(&headers, prefix, access_time).unwrap();
assert_eq!(inserted.custom, metadata.custom);
}
}
#[test]
fn from_headers_does_not_validate_custom_keys() {
let mut headers = HeaderMap::new();
headers.insert("x-snme-a*b", "v".parse().unwrap());
headers.insert("x-snme-100%", "legacy".parse().unwrap());
headers.insert("x-snme-", "empty".parse().unwrap());
let metadata = Metadata::from_headers(&headers, "").unwrap();
assert_eq!(metadata.custom.get("a*b").unwrap(), "v");
assert_eq!(metadata.custom.get("100%").unwrap(), "legacy");
assert_eq!(metadata.custom.get("").unwrap(), "empty");
}
#[test]
fn from_insert_headers_rejects_invalid_custom_keys() {
let access_time = Timestamp::from_unix_secs(1_700_000_000).unwrap();
for name in [
"x-snme-a*b",
"x-snme-a!b",
"x-snme-a%ffb",
"x-snme-a%20b",
"x-snme-",
] {
let mut headers = HeaderMap::new();
headers.insert(name, "v".parse().unwrap());
std::assert_matches!(
Metadata::from_insert_headers(&headers, "", access_time),
Err(Error::CustomKey(_)),
"accepted {name}"
);
}
}
#[test]
fn from_headers_invalid_content_type() {
let mut headers = HeaderMap::new();
headers.insert("content-type", "not a valid media type!".parse().unwrap());
let err = Metadata::from_headers(&headers, "").unwrap_err();
assert!(matches!(err, Error::ContentType(_)));
}
#[test]
fn from_headers_invalid_compression() {
let mut headers = HeaderMap::new();
headers.insert("content-encoding", "brotli".parse().unwrap());
let err = Metadata::from_headers(&headers, "").unwrap_err();
assert!(matches!(err, Error::Compression));
}
#[test]
fn from_headers_invalid_expiration() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_EXPIRATION, "garbage".parse().unwrap());
let err = Metadata::from_headers(&headers, "").unwrap_err();
assert!(matches!(err, Error::Expiration(_)));
}
#[test]
fn from_headers_invalid_timestamp() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_TIME_CREATED, "not-a-timestamp".parse().unwrap());
let err = Metadata::from_headers(&headers, "").unwrap_err();
assert!(matches!(err, Error::CreationTime(_)));
}
#[test]
fn to_headers_all_fields() {
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToLive(Duration::from_mins(1)),
time_created: Some(Timestamp::from_unix_secs(1_700_000_000).unwrap()),
time_expires: Some(Timestamp::from_unix_secs(1_700_000_060).unwrap()),
content_type: "text/html".into(),
compression: Some(Compression::Zstd),
origin: Some("10.0.0.1".into()),
filename: Some("report.pdf".into()),
size: None,
custom: BTreeMap::from([("foo".into(), "bar".into())]),
};
let headers = metadata.to_headers("pfx-").unwrap();
let map: BTreeMap<_, _> = headers
.iter()
.map(|(k, v)| (k.as_str(), v.to_str().unwrap()))
.collect();
insta::assert_debug_snapshot!(map, @r#"
{
"content-encoding": "zstd",
"content-type": "text/html",
"pfx-x-sn-expiration": "ttl:1m",
"pfx-x-sn-filename": "report.pdf",
"pfx-x-sn-origin": "10.0.0.1",
"pfx-x-sn-time-created": "2023-11-14T22:13:20Z",
"pfx-x-sn-time-expires": "2023-11-14T22:14:20Z",
"pfx-x-snme-foo": "bar",
}
"#);
}
#[test]
fn full_roundtrip_all_fields() {
let prefix = "x-test-";
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(Duration::from_hours(2)),
time_created: Some(Timestamp::from_unix_secs(1_700_000_000).unwrap()),
time_expires: Some(Timestamp::from_unix_secs(1_700_007_200).unwrap()),
content_type: "image/png".into(),
compression: Some(Compression::Zstd),
origin: Some("192.168.1.1".into()),
filename: Some("image.png".into()),
size: None,
custom: BTreeMap::from([
("key1".into(), "value1".into()),
("key2".into(), "value2".into()),
]),
};
let headers = metadata.to_headers(prefix).unwrap();
let roundtripped = Metadata::from_headers(&headers, prefix).unwrap();
assert_eq!(roundtripped.expiration_policy, metadata.expiration_policy);
assert_eq!(roundtripped.content_type, metadata.content_type);
assert_eq!(roundtripped.compression, metadata.compression);
assert_eq!(roundtripped.origin, metadata.origin);
assert_eq!(roundtripped.filename, metadata.filename);
assert_eq!(roundtripped.time_created, metadata.time_created);
assert_eq!(roundtripped.time_expires, metadata.time_expires);
assert_eq!(roundtripped.custom, metadata.custom);
}
#[test]
fn from_headers_empty() {
let headers = HeaderMap::new();
let metadata = Metadata::from_headers(&headers, "x-goog-meta-").unwrap();
assert_eq!(metadata, Metadata::default());
}
#[test]
fn from_headers_invalid_time_expires() {
let mut headers = HeaderMap::new();
let name: HeaderName = format!("x-goog-meta-{HEADER_TIME_EXPIRES}")
.parse()
.unwrap();
headers.insert(name, "not-a-timestamp".parse().unwrap());
assert!(Metadata::from_headers(&headers, "x-goog-meta-").is_err());
}
#[test]
fn serde_roundtrip_default() {
let metadata = Metadata::default();
let json = serde_json::to_string(&metadata).unwrap();
let deserialized: Metadata = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, metadata);
}
#[test]
fn serde_roundtrip_all_fields() {
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(Duration::from_hours(1)),
time_created: Some(Timestamp::from_unix_secs(1_700_000_000).unwrap()),
time_expires: Some(Timestamp::from_unix_secs(1_700_003_600).unwrap()),
content_type: "application/json".into(),
compression: Some(Compression::Zstd),
origin: Some("10.0.0.1".into()),
filename: Some("data.json".into()),
size: Some(1024),
custom: BTreeMap::from([("key".into(), "value".into())]),
};
let json = serde_json::to_string(&metadata).unwrap();
let deserialized: Metadata = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, metadata);
}
#[test]
fn size_roundtrips_through_headers() {
let metadata = Metadata {
size: Some(42),
..Default::default()
};
let headers = metadata.to_headers("").unwrap();
assert_eq!(headers.get(HEADER_SIZE).unwrap(), "42");
assert_eq!(Metadata::from_headers(&headers, "").unwrap().size, Some(42));
}
#[test]
fn size_is_prefixed_in_headers() {
let metadata = Metadata {
size: Some(42),
..Default::default()
};
let headers = metadata.to_headers("x-goog-meta-").unwrap();
assert_eq!(headers.get("x-goog-meta-x-sn-size").unwrap(), "42");
}
#[test]
fn from_insert_headers_ignores_size() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_SIZE, "9999".parse().unwrap());
let metadata = Metadata::from_insert_headers(&headers, "", Timestamp::now()).unwrap();
assert!(metadata.size.is_none());
}
#[test]
fn from_headers_rejects_malformed_size() {
let mut headers = HeaderMap::new();
headers.insert(HEADER_SIZE, "not-a-number".parse().unwrap());
assert!(matches!(
Metadata::from_headers(&headers, ""),
Err(Error::Size(_))
));
}
#[test]
fn default_metadata() {
let metadata = Metadata::default();
assert_eq!(metadata.content_type, DEFAULT_CONTENT_TYPE);
assert_eq!(metadata.expiration_policy, ExpirationPolicy::Manual);
assert!(metadata.compression.is_none());
assert!(metadata.origin.is_none());
assert!(metadata.filename.is_none());
assert!(metadata.time_created.is_none());
assert!(metadata.time_expires.is_none());
assert!(metadata.size.is_none());
assert!(metadata.custom.is_empty());
}
#[test]
fn expiration_display_roundtrip() {
let cases = [
ExpirationPolicy::Manual,
ExpirationPolicy::TimeToLive(Duration::from_secs(30)),
ExpirationPolicy::TimeToIdle(Duration::from_hours(1)),
];
for policy in cases {
let displayed = policy.to_string();
let parsed: ExpirationPolicy = displayed.parse().unwrap();
assert_eq!(parsed, policy);
}
}
#[test]
fn expiration_parse_invalid() {
assert!(ExpirationPolicy::from_str("garbage").is_err());
assert!(ExpirationPolicy::from_str("ttl:").is_err());
assert!(ExpirationPolicy::from_str("").is_err());
}
#[test]
fn expiration_policy_helpers() {
assert_eq!(ExpirationPolicy::Manual.expires_in(), None);
assert!(ExpirationPolicy::Manual.is_manual());
assert!(!ExpirationPolicy::Manual.is_timeout());
let ttl = ExpirationPolicy::TimeToLive(Duration::from_mins(1));
assert_eq!(ttl.expires_in(), Some(Duration::from_mins(1)));
assert!(ttl.is_timeout());
assert!(!ttl.is_manual());
let tti = ExpirationPolicy::TimeToIdle(Duration::from_mins(2));
assert_eq!(tti.expires_in(), Some(Duration::from_mins(2)));
assert!(tti.is_timeout());
assert!(!tti.is_manual());
}
#[test]
fn compression_display_roundtrip() {
for (compression, expected) in [(Compression::Zstd, "zstd"), (Compression::Gzip, "gzip")] {
let displayed = compression.to_string();
assert_eq!(displayed, expected);
let parsed: Compression = displayed.parse().unwrap();
assert_eq!(parsed, compression);
}
}
#[test]
fn compression_parse_invalid() {
assert!(Compression::from_str("lz4").is_err());
assert!(Compression::from_str("").is_err());
}
#[test]
fn check_tti_bump_returns_none_for_manual() {
let metadata = Metadata::default();
assert!(metadata.check_tti_bump(Timestamp::now()).is_none());
}
#[test]
fn check_tti_bump_returns_none_for_ttl() {
let now = Timestamp::now();
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToLive(Duration::from_hours(1)),
time_expires: Some(now + Duration::from_hours(1)),
..Default::default()
};
assert!(metadata.check_tti_bump(now).is_none());
}
#[test]
fn check_tti_bump_returns_none_when_fresh() {
let now = Timestamp::now();
let tti = Duration::from_hours(2 * 24);
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(tti),
time_expires: Some(now + tti),
..Default::default()
};
assert!(metadata.check_tti_bump(now).is_none());
}
#[test]
fn check_tti_bump_returns_new_deadline_when_stale() {
let now = Timestamp::now();
let tti = Duration::from_hours(2 * 24);
let debounce = tti / 4;
let stale_deadline = now + tti - debounce - Duration::from_mins(1);
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(tti),
time_expires: Some(stale_deadline),
..Default::default()
};
let new_deadline = metadata.check_tti_bump(now).unwrap();
assert_eq!(new_deadline, now + tti);
}
#[test]
fn check_tti_bump_short_tti_triggers_bump() {
let now = Timestamp::now();
for tti in [
Duration::from_hours(2),
Duration::from_secs(3),
Duration::from_secs(4),
] {
let debounce = tti / 4;
let new_deadline = now + tti;
let mut metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(tti),
time_expires: Some(new_deadline - Duration::from_secs(debounce.as_secs() + 1)),
..Default::default()
};
assert_eq!(metadata.check_tti_bump(now), Some(new_deadline));
metadata.time_expires = Some(new_deadline - Duration::from_secs(debounce.as_secs()));
assert!(metadata.check_tti_bump(now).is_none());
}
}
#[test]
fn check_tti_bump_debounce_caps_at_24h() {
let now = Timestamp::now();
let tti = Duration::from_hours(30 * 24);
let capped_debounce = Duration::from_hours(24);
let stale_deadline = now + tti - capped_debounce - Duration::from_mins(1);
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(tti),
time_expires: Some(stale_deadline),
..Default::default()
};
assert!(metadata.check_tti_bump(now).is_some());
let fresh_deadline = now + tti - capped_debounce + Duration::from_mins(1);
let metadata = Metadata {
time_expires: Some(fresh_deadline),
..metadata
};
assert!(metadata.check_tti_bump(now).is_none());
}
#[test]
fn check_tti_bump_returns_none_when_time_expires_missing() {
let metadata = Metadata {
expiration_policy: ExpirationPolicy::TimeToIdle(Duration::from_hours(1)),
time_expires: None,
..Default::default()
};
assert!(metadata.check_tti_bump(Timestamp::now()).is_none());
}
fn write_json(json: &str) -> Result<Metadata, Error> {
let insert: WriteMetadata = serde_json::from_str(json).unwrap();
insert.into_metadata(Timestamp::from_unix_secs(1_700_000_000).unwrap())
}
fn full_metadata() -> Metadata {
Metadata {
expiration_policy: ExpirationPolicy::TimeToLive(Duration::from_hours(30 * 24)),
time_created: Some(Timestamp::from_unix_secs(1_700_000_000).unwrap()),
time_expires: Some(Timestamp::from_unix_secs(1_702_592_000).unwrap()),
content_type: "image/png".into(),
compression: Some(Compression::Zstd),
origin: Some("203.0.113.42".into()),
filename: Some("résumé.png".into()),
size: Some(1024),
custom: BTreeMap::from([("build".into(), "123".into())]),
}
}
#[test]
fn write_metadata_minimal() {
let metadata = write_json("{}").unwrap();
assert_eq!(
metadata,
Metadata {
time_created: Some(Timestamp::from_unix_secs(1_700_000_000).unwrap()),
..Default::default()
}
);
let json = serde_json::to_string(&WriteMetadata::from(Metadata::default())).unwrap();
assert_eq!(json, "{}");
}
#[test]
fn write_metadata_full() {
let expected = Metadata {
size: None,
..full_metadata()
};
let json = serde_json::to_string(&WriteMetadata::from(full_metadata())).unwrap();
assert_eq!(
json,
r#"{"content_type":"image/png","content_encoding":"zstd","expiration":"ttl:30d","origin":"203.0.113.42","filename":"résumé.png","custom":{"build":"123"}}"#
);
assert_eq!(write_json(&json).unwrap(), expected);
}
#[test]
fn write_metadata_odd_cases() {
let json = r#"{
"future": 1,
"size": 9,
"time_created": "2020-01-01T00:00:00Z",
"filename": "50%41.txt",
"custom": {"Build": "100%25"}
}"#;
let metadata = write_json(json).unwrap();
assert_eq!(
metadata.time_created,
Some(Timestamp::from_unix_secs(1_700_000_000).unwrap())
);
assert_eq!(metadata.size, None);
assert_eq!(metadata.filename.as_deref(), Some("50%41.txt"));
assert_eq!(metadata.custom["build"], "100%25");
for json in [
r#"{"content_type":"not a media type!"}"#,
r#"{"content_encoding":"brotli"}"#,
r#"{"expiration":"garbage"}"#,
r#"{"custom":{"a b":"v"}}"#,
] {
assert!(write_json(json).is_err(), "unexpectedly accepted {json}");
}
}
#[test]
fn write_metadata_matches_insert_headers() {
let access_time = Timestamp::from_unix_secs(1_700_000_000).unwrap();
for expiration in ["manual", "ttl:30d", "tti:1h"] {
let mut headers = HeaderMap::new();
headers.insert("content-type", "text/plain".parse().unwrap());
headers.insert(HEADER_EXPIRATION, expiration.parse().unwrap());
let from_headers = Metadata::from_insert_headers(&headers, "", access_time).unwrap();
let json = format!(r#"{{"content_type":"text/plain","expiration":"{expiration}"}}"#);
assert_eq!(write_json(&json).unwrap(), from_headers, "{expiration}");
}
}
#[test]
fn read_metadata_minimal() {
let json = serde_json::to_string(&ReadMetadata::from(Metadata::default())).unwrap();
assert_eq!(json, r#"{"content_type":"application/octet-stream"}"#);
let object: ReadMetadata = serde_json::from_str(&json).unwrap();
assert_eq!(Metadata::try_from(object).unwrap(), Metadata::default());
}
#[test]
fn read_metadata_full() {
let json = serde_json::to_string_pretty(&ReadMetadata::from(full_metadata())).unwrap();
insta::assert_snapshot!(json, @r#"
{
"content_type": "image/png",
"content_encoding": "zstd",
"expiration": "ttl:30d",
"origin": "203.0.113.42",
"filename": "résumé.png",
"custom": {
"build": "123"
},
"time_created": "2023-11-14T22:13:20Z",
"time_expires": "2023-12-14T22:13:20Z",
"size": 1024
}
"#);
let object: ReadMetadata = serde_json::from_str(&json).unwrap();
assert_eq!(Metadata::try_from(object).unwrap(), full_metadata());
}
#[test]
fn read_metadata_odd_cases() {
let json = r#"{"content_type":"text/plain","future":1,"custom":{"a*b":"v"}}"#;
let object: ReadMetadata = serde_json::from_str(json).unwrap();
assert_eq!(Metadata::try_from(object).unwrap().custom["a*b"], "v");
let json = r#"{"content_type":"text/plain","expiration":"garbage"}"#;
let object: ReadMetadata = serde_json::from_str(json).unwrap();
assert!(Metadata::try_from(object).is_err());
}
}