use super::{AudioCodec, SubtitleCodec, VideoCodec};
#[cfg(feature = "mongo")]
#[test]
fn a_codec_carries_as_the_canonical_slug() {
use bson::Bson;
use crate::MongoCarrier;
assert_eq!(
VideoCodec::new("h264").to_bson(),
Bson::String(String::from("h264"))
);
assert_eq!(
AudioCodec::new("aac").to_bson(),
Bson::String(String::from("aac"))
);
assert_eq!(
SubtitleCodec::new("subrip").to_bson(),
Bson::String(String::from("subrip"))
);
for (sent, canonical) in [("H264", "h264"), ("H264", "h264"), ("AV1", "av1")] {
assert_eq!(
VideoCodec::new(sent).to_bson(),
VideoCodec::new(canonical).to_bson(),
"`{sent}` and `{canonical}` reach one document",
);
}
assert_eq!(
VideoCodec::new("some_codec_9000").to_bson(),
Bson::String(String::from("some_codec_9000")),
);
}
#[cfg(feature = "mongo")]
#[test]
fn a_codec_reads_back_the_document_it_carried_as() {
use crate::{MongoCarrier, query::mongo::MongoExtract};
for sent in ["h264", "H264", "av1", "some_codec_9000", ""] {
let codec = VideoCodec::new(sent);
let written = codec.to_bson();
assert_eq!(VideoCodec::extract(Some(&written)), Ok(codec), "`{sent}`");
}
for sent in ["aac", "OPUS", "flac"] {
let codec = AudioCodec::new(sent);
let written = codec.to_bson();
assert_eq!(AudioCodec::extract(Some(&written)), Ok(codec), "`{sent}`");
}
for sent in ["subrip", "ASS", "dvb_subtitle"] {
let codec = SubtitleCodec::new(sent);
let written = codec.to_bson();
assert_eq!(
SubtitleCodec::extract(Some(&written)),
Ok(codec),
"`{sent}`"
);
}
}
#[cfg(feature = "mongo")]
#[test]
fn a_hand_written_document_folds_at_the_read_door() {
use bson::Bson;
use crate::query::mongo::MongoExtract;
assert_eq!(
VideoCodec::extract(Some(&Bson::String(String::from("H264")))),
Ok(VideoCodec::new("h264")),
"a document written in the wrong case reads back canonical",
);
assert_eq!(
VideoCodec::extract(Some(&Bson::String(String::from("!!!")))),
Ok(VideoCodec::new("!!!")),
);
}
#[cfg(feature = "mongo")]
#[test]
fn a_codec_read_refuses_absence_and_the_wrong_type_by_name() {
use bson::Bson;
use crate::query::mongo::{MongoExtract, MongoTypeError};
assert_eq!(VideoCodec::extract(None), Err(MongoTypeError::Absent));
assert_eq!(AudioCodec::extract(None), Err(MongoTypeError::Absent));
assert_eq!(SubtitleCodec::extract(None), Err(MongoTypeError::Absent));
let refused = VideoCodec::extract(Some(&Bson::Int32(7)));
assert!(
matches!(refused, Err(MongoTypeError::Type { .. })),
"a number where a codec belongs is a TYPE refusal, got {refused:?}",
);
assert!(matches!(
VideoCodec::extract(Some(&Bson::Boolean(true))),
Err(MongoTypeError::Type { .. })
));
}
#[test]
fn the_cursor_position_is_the_slug_and_round_trips() {
use crate::CursorValue;
for sent in ["h264", "H264", "some_codec_9000", ""] {
let codec = VideoCodec::new(sent);
let mut written = Vec::new();
codec.write_cursor(&mut written);
assert_eq!(
written,
codec.as_str().as_bytes(),
"`{sent}` writes its canonical slug and nothing around it",
);
assert_eq!(
VideoCodec::read_cursor(&written),
Some(codec),
"`{sent}` reads back as itself",
);
}
let mut written = Vec::new();
VideoCodec::new("av1").write_cursor(&mut written);
let mut later = Vec::new();
VideoCodec::new("h264").write_cursor(&mut later);
assert!(
written < later,
"the cursor bytes carry the type's own order"
);
assert_eq!(VideoCodec::read_cursor(&[0xff, 0xfe]), None);
assert_eq!(AudioCodec::read_cursor(&[0xff, 0xfe]), None);
assert_eq!(SubtitleCodec::read_cursor(&[0xff, 0xfe]), None);
}
#[test]
fn a_cursor_read_canonicalises() {
use crate::CursorValue;
assert_eq!(
VideoCodec::read_cursor(b"H264"),
Some(VideoCodec::new("h264")),
);
}