use super::*;
fn entries_of(source: &str) -> Vec<(String, Entry)> {
parse_entries(source).expect("source should parse")
}
fn entry_named<'a>(entries: &'a [(String, Entry)], key: &str) -> &'a Entry {
&entries
.iter()
.find(|(k, _)| k == key)
.unwrap_or_else(|| panic!("no entry keyed `{key}`"))
.1
}
#[test]
fn parses_single_entry() {
let source = r#"
@article{smith2020,
author = {Jane Smith},
title = {On Small Things},
year = {2020}
}
"#;
let entries = entries_of(source);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, "smith2020");
assert_eq!(entries[0].1.entry_type, "article");
assert_eq!(entries[0].1.fields["author"], "Jane Smith");
assert_eq!(entries[0].1.fields["title"], "On Small Things");
assert_eq!(entries[0].1.fields["year"], "2020");
}
#[test]
fn parses_multiple_entries_in_one_source() {
let source = r#"
@article{first, title = {First} }
@book{second, title = {Second} }
"#;
let entries = entries_of(source);
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].0, "first");
assert_eq!(entries[1].0, "second");
assert_eq!(entries[1].1.entry_type, "book");
}
#[test]
fn parses_quote_delimited_values() {
let source = r#"@article{k, title = "A Quoted Title", year = "1999"}"#;
let entry = &entries_of(source)[0].1;
assert_eq!(entry.fields["title"], "A Quoted Title");
assert_eq!(entry.fields["year"], "1999");
}
#[test]
fn parses_bare_undelimited_value() {
let source = "@article{k, year = 2020}";
assert_eq!(entries_of(source)[0].1.fields["year"], "2020");
}
#[test]
fn strips_nested_capitalization_braces_from_value() {
let source = "@article{k, title = {A {Special} Title}}";
assert_eq!(entries_of(source)[0].1.fields["title"], "A Special Title");
}
#[test]
fn keeps_comma_inside_braced_value_as_part_of_the_value() {
let source = "@article{k, author = {Smith, Jane and Doe, John}, year = {2020}}";
let entry = &entries_of(source)[0].1;
assert_eq!(entry.fields["author"], "Smith, Jane and Doe, John");
assert_eq!(entry.fields["year"], "2020");
}
#[test]
fn accepts_trailing_comma_after_last_field() {
let source = "@article{k, title = {T}, year = {2020},}";
let entry = &entries_of(source)[0].1;
assert_eq!(entry.fields.len(), 2);
assert_eq!(entry.fields["year"], "2020");
}
#[test]
fn collapses_whitespace_in_multi_line_value() {
let source = r#"@article{k,
title = {A Title That Spans
More Than One
Line}
}"#;
assert_eq!(
entries_of(source)[0].1.fields["title"],
"A Title That Spans More Than One Line"
);
}
#[test]
fn lowercases_field_names() {
let source = "@article{k, Author = {A}, TITLE = {T}, YeAr = {2020}}";
let entry = &entries_of(source)[0].1;
assert_eq!(entry.fields["author"], "A");
assert_eq!(entry.fields["title"], "T");
assert_eq!(entry.fields["year"], "2020");
}
#[test]
fn lowercases_entry_type() {
let source = "@ARTICLE{k, title = {T}}";
assert_eq!(entries_of(source)[0].1.entry_type, "article");
}
#[test]
fn duplicate_field_name_keeps_last_value() {
let source = "@article{k, title = {First}, title = {Second}}";
let entry = &entries_of(source)[0].1;
assert_eq!(entry.fields.len(), 1);
assert_eq!(entry.fields["title"], "Second");
}
#[test]
fn discards_comment_block_without_affecting_neighbours() {
let source = r#"
@article{before, title = {Before} }
@comment{ this is a note with an unbalanced-looking } brace pair {}
@article{after, title = {After} }
"#;
let entries = entries_of(source);
assert_eq!(entries.len(), 2);
assert_eq!(entry_named(&entries, "before").fields["title"], "Before");
assert_eq!(entry_named(&entries, "after").fields["title"], "After");
}
#[test]
fn discards_string_block_without_affecting_neighbours() {
let source = r#"
@string{jml = {Journal of Minimal Things}}
@article{after, title = {After} }
"#;
let entries = entries_of(source);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, "after");
}
#[test]
fn skips_stray_text_between_entries() {
let source = r#"
This file was exported by a tool that writes prose headers.
@article{first, title = {First} }
Some more stray commentary, not an entry.
@book{second, title = {Second} }
"#;
let entries = entries_of(source);
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].0, "first");
assert_eq!(entries[1].0, "second");
}
#[test]
fn empty_source_parses_to_no_entries() {
assert!(entries_of("").is_empty());
assert!(entries_of("\n \n").is_empty());
}
#[test]
fn missing_closing_brace_is_a_parse_error() {
let source = "@article{k, title = {Unterminated}";
let error = parse_entries(source).expect_err("unterminated entry should not parse");
assert!(
matches!(&error, CiteError::Parse { file: None, message } if message.contains("closing")),
"expected a Parse error mentioning the closing brace, got: {error}"
);
}
#[test]
fn entry_without_opening_brace_is_a_parse_error() {
let source = "@article";
let error = parse_entries(source).expect_err("entry with no body should not parse");
assert!(matches!(error, CiteError::Parse { .. }));
}
#[test]
fn field_without_equals_is_a_parse_error() {
let source = "@article{k, title}";
let error = parse_entries(source).expect_err("field with no `=` should not parse");
assert!(
matches!(&error, CiteError::Parse { message, .. } if message.contains('k')),
"error should name the entry the bad field is in, got: {error}"
);
}
#[test]
fn entry_without_citation_key_is_a_parse_error() {
let source = "@article{, title = {T}}";
let error = parse_entries(source).expect_err("entry with no key should not parse");
assert!(
matches!(&error, CiteError::Parse { message, .. } if message.contains("key")),
"expected a Parse error mentioning the missing key, got: {error}"
);
}
#[test]
fn entry_with_key_but_no_fields_parses_to_empty_fields() {
let source = "@misc{lonely}";
let entry = &entries_of(source)[0].1;
assert_eq!(entry.entry_type, "misc");
assert!(entry.fields.is_empty());
}