Skip to content

Commit 2a3fb79

Browse files
joshkajoshka
committed
Manually parameterize tests, add comments about deserialization
1 parent bc139a6 commit 2a3fb79

File tree

1 file changed

+117
-198
lines changed

1 file changed

+117
-198
lines changed

‎src/lib.rs

+117-198
Original file line numberDiff line numberDiff line change
@@ -371,216 +371,132 @@ mod test {
371371
}
372372

373373
#[test]
374-
fn from_level_filter() {
375-
// ErrorLevel
376-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Off);
377-
assert_eq!(v, Verbosity::new(0, 1));
378-
379-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Error);
380-
assert_eq!(v, Verbosity::new(0, 0));
381-
382-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Warn);
383-
assert_eq!(v, Verbosity::new(1, 0));
384-
385-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Info);
386-
assert_eq!(v, Verbosity::new(2, 0));
387-
388-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Debug);
389-
assert_eq!(v, Verbosity::new(3, 0));
390-
391-
let v = Verbosity::<ErrorLevel>::from(LevelFilter::Trace);
392-
assert_eq!(v, Verbosity::new(4, 0));
393-
394-
// WarnLevel
395-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Off);
396-
assert_eq!(v, Verbosity::new(0, 2));
397-
398-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Error);
399-
assert_eq!(v, Verbosity::new(0, 1));
400-
401-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Warn);
402-
assert_eq!(v, Verbosity::new(0, 0));
403-
404-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Info);
405-
assert_eq!(v, Verbosity::new(1, 0));
406-
407-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Debug);
408-
assert_eq!(v, Verbosity::new(2, 0));
374+
fn from_level_filter_error_level() {
375+
let tests = [
376+
(LevelFilter::Off, Verbosity::<ErrorLevel>::new(0, 1)),
377+
(LevelFilter::Error, Verbosity::<ErrorLevel>::new(0, 0)),
378+
(LevelFilter::Warn, Verbosity::<ErrorLevel>::new(1, 0)),
379+
(LevelFilter::Info, Verbosity::<ErrorLevel>::new(2, 0)),
380+
(LevelFilter::Debug, Verbosity::<ErrorLevel>::new(3, 0)),
381+
(LevelFilter::Trace, Verbosity::<ErrorLevel>::new(4, 0)),
382+
];
383+
for (filter, expected) in tests.iter() {
384+
let verbosity = Verbosity::from(*filter);
385+
assert_eq!(verbosity, *expected,);
386+
assert_eq!(verbosity.log_level_filter(), *filter,);
387+
}
388+
}
409389

410-
let v = Verbosity::<WarnLevel>::from(LevelFilter::Trace);
411-
assert_eq!(v, Verbosity::new(3, 0));
390+
#[test]
391+
fn from_level_filter_warn_level() {
392+
let tests = [
393+
(LevelFilter::Off, Verbosity::<WarnLevel>::new(0, 2)),
394+
(LevelFilter::Error, Verbosity::<WarnLevel>::new(0, 1)),
395+
(LevelFilter::Warn, Verbosity::<WarnLevel>::new(0, 0)),
396+
(LevelFilter::Info, Verbosity::<WarnLevel>::new(1, 0)),
397+
(LevelFilter::Debug, Verbosity::<WarnLevel>::new(2, 0)),
398+
(LevelFilter::Trace, Verbosity::<WarnLevel>::new(3, 0)),
399+
];
400+
for (filter, expected) in tests.iter() {
401+
let verbosity = Verbosity::from(*filter);
402+
assert_eq!(verbosity, *expected,);
403+
assert_eq!(verbosity.log_level_filter(), *filter,);
404+
}
405+
}
412406

413-
// InfoLevel
414-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Off);
415-
assert_eq!(v, Verbosity::new(0, 3));
407+
#[test]
408+
fn from_level_filter_info_level() {
409+
let tests = [
410+
(LevelFilter::Off, Verbosity::<InfoLevel>::new(0, 3)),
411+
(LevelFilter::Error, Verbosity::<InfoLevel>::new(0, 2)),
412+
(LevelFilter::Warn, Verbosity::<InfoLevel>::new(0, 1)),
413+
(LevelFilter::Info, Verbosity::<InfoLevel>::new(0, 0)),
414+
(LevelFilter::Debug, Verbosity::<InfoLevel>::new(1, 0)),
415+
(LevelFilter::Trace, Verbosity::<InfoLevel>::new(2, 0)),
416+
];
417+
for (filter, expected) in tests.iter() {
418+
let verbosity = Verbosity::from(*filter);
419+
assert_eq!(verbosity, *expected,);
420+
assert_eq!(verbosity.log_level_filter(), *filter,);
421+
}
422+
}
416423

417-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Error);
418-
assert_eq!(v, Verbosity::new(0, 2));
424+
#[test]
425+
#[cfg(feature = "serde")]
426+
fn serde_error_level() {
427+
use serde_test::{assert_tokens, Token};
419428

420-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Warn);
421-
assert_eq!(v, Verbosity::new(0, 1));
429+
let tests = [
430+
(Verbosity::<ErrorLevel>::new(0, 1), "OFF"),
431+
(Verbosity::<ErrorLevel>::new(0, 0), "ERROR"),
432+
(Verbosity::<ErrorLevel>::new(1, 0), "WARN"),
433+
(Verbosity::<ErrorLevel>::new(2, 0), "INFO"),
434+
(Verbosity::<ErrorLevel>::new(3, 0), "DEBUG"),
435+
(Verbosity::<ErrorLevel>::new(4, 0), "TRACE"),
436+
];
422437

423-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Info);
424-
assert_eq!(v, Verbosity::new(0, 0));
438+
// check that the verbosity round-trips through serde
439+
for (verbosity, variant) in tests.iter() {
440+
assert_tokens(
441+
verbosity,
442+
&[Token::UnitVariant {
443+
name: "LevelFilter",
444+
variant,
445+
}],
446+
);
447+
}
448+
}
425449

426-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Debug);
427-
assert_eq!(v, Verbosity::new(1, 0));
450+
#[test]
451+
#[cfg(feature = "serde")]
452+
fn serde_warn_level() {
453+
use serde_test::{assert_tokens, Token};
428454

429-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Trace);
430-
assert_eq!(v, Verbosity::new(2, 0));
455+
let tests = [
456+
(Verbosity::<WarnLevel>::new(0, 2), "OFF"),
457+
(Verbosity::<WarnLevel>::new(0, 1), "ERROR"),
458+
(Verbosity::<WarnLevel>::new(0, 0), "WARN"),
459+
(Verbosity::<WarnLevel>::new(1, 0), "INFO"),
460+
(Verbosity::<WarnLevel>::new(2, 0), "DEBUG"),
461+
(Verbosity::<WarnLevel>::new(3, 0), "TRACE"),
462+
];
431463

432-
let v = Verbosity::<InfoLevel>::from(LevelFilter::Trace);
433-
assert_eq!(v, Verbosity::new(2, 0));
464+
// check that the verbosity round-trips through serde
465+
for (verbosity, variant) in tests.iter() {
466+
assert_tokens(
467+
verbosity,
468+
&[Token::UnitVariant {
469+
name: "LevelFilter",
470+
variant,
471+
}],
472+
);
473+
}
434474
}
435475

436476
#[test]
437477
#[cfg(feature = "serde")]
438-
fn serde() {
478+
fn serde_info_level() {
439479
use serde_test::{assert_tokens, Token};
440480

441-
assert_tokens(
442-
&Verbosity::<ErrorLevel>::new(0, 1),
443-
&[Token::UnitVariant {
444-
name: "LevelFilter",
445-
variant: "OFF",
446-
}],
447-
);
448-
449-
assert_tokens(
450-
&Verbosity::<ErrorLevel>::new(0, 0),
451-
&[Token::UnitVariant {
452-
name: "LevelFilter",
453-
variant: "ERROR",
454-
}],
455-
);
456-
457-
assert_tokens(
458-
&Verbosity::<ErrorLevel>::new(1, 0),
459-
&[Token::UnitVariant {
460-
name: "LevelFilter",
461-
variant: "WARN",
462-
}],
463-
);
464-
465-
assert_tokens(
466-
&Verbosity::<ErrorLevel>::new(2, 0),
467-
&[Token::UnitVariant {
468-
name: "LevelFilter",
469-
variant: "INFO",
470-
}],
471-
);
472-
473-
assert_tokens(
474-
&Verbosity::<ErrorLevel>::new(3, 0),
475-
&[Token::UnitVariant {
476-
name: "LevelFilter",
477-
variant: "DEBUG",
478-
}],
479-
);
480-
481-
assert_tokens(
482-
&Verbosity::<ErrorLevel>::new(4, 0),
483-
&[Token::UnitVariant {
484-
name: "LevelFilter",
485-
variant: "TRACE",
486-
}],
487-
);
488-
489-
assert_tokens(
490-
&Verbosity::<WarnLevel>::new(0, 2),
491-
&[Token::UnitVariant {
492-
name: "LevelFilter",
493-
variant: "OFF",
494-
}],
495-
);
496-
497-
assert_tokens(
498-
&Verbosity::<WarnLevel>::new(0, 1),
499-
&[Token::UnitVariant {
500-
name: "LevelFilter",
501-
variant: "ERROR",
502-
}],
503-
);
504-
505-
assert_tokens(
506-
&Verbosity::<WarnLevel>::new(0, 0),
507-
&[Token::UnitVariant {
508-
name: "LevelFilter",
509-
variant: "WARN",
510-
}],
511-
);
512-
513-
assert_tokens(
514-
&Verbosity::<WarnLevel>::new(1, 0),
515-
&[Token::UnitVariant {
516-
name: "LevelFilter",
517-
variant: "INFO",
518-
}],
519-
);
520-
521-
assert_tokens(
522-
&Verbosity::<WarnLevel>::new(2, 0),
523-
&[Token::UnitVariant {
524-
name: "LevelFilter",
525-
variant: "DEBUG",
526-
}],
527-
);
528-
529-
assert_tokens(
530-
&Verbosity::<WarnLevel>::new(3, 0),
531-
&[Token::UnitVariant {
532-
name: "LevelFilter",
533-
variant: "TRACE",
534-
}],
535-
);
536-
537-
assert_tokens(
538-
&Verbosity::<InfoLevel>::new(0, 3),
539-
&[Token::UnitVariant {
540-
name: "LevelFilter",
541-
variant: "OFF",
542-
}],
543-
);
544-
545-
assert_tokens(
546-
&Verbosity::<InfoLevel>::new(0, 2),
547-
&[Token::UnitVariant {
548-
name: "LevelFilter",
549-
variant: "ERROR",
550-
}],
551-
);
552-
553-
assert_tokens(
554-
&Verbosity::<InfoLevel>::new(0, 1),
555-
&[Token::UnitVariant {
556-
name: "LevelFilter",
557-
variant: "WARN",
558-
}],
559-
);
560-
561-
assert_tokens(
562-
&Verbosity::<InfoLevel>::new(0, 0),
563-
&[Token::UnitVariant {
564-
name: "LevelFilter",
565-
variant: "INFO",
566-
}],
567-
);
568-
569-
assert_tokens(
570-
&Verbosity::<InfoLevel>::new(1, 0),
571-
&[Token::UnitVariant {
572-
name: "LevelFilter",
573-
variant: "DEBUG",
574-
}],
575-
);
576-
577-
assert_tokens(
578-
&Verbosity::<InfoLevel>::new(2, 0),
579-
&[Token::UnitVariant {
580-
name: "LevelFilter",
581-
variant: "TRACE",
582-
}],
583-
);
481+
let tests = [
482+
(Verbosity::<InfoLevel>::new(0, 3), "OFF"),
483+
(Verbosity::<InfoLevel>::new(0, 2), "ERROR"),
484+
(Verbosity::<InfoLevel>::new(0, 1), "WARN"),
485+
(Verbosity::<InfoLevel>::new(0, 0), "INFO"),
486+
(Verbosity::<InfoLevel>::new(1, 0), "DEBUG"),
487+
(Verbosity::<InfoLevel>::new(2, 0), "TRACE"),
488+
];
489+
490+
// check that the verbosity round-trips through serde
491+
for (verbosity, variant) in tests.iter() {
492+
assert_tokens(
493+
verbosity,
494+
&[Token::UnitVariant {
495+
name: "LevelFilter",
496+
variant,
497+
}],
498+
);
499+
}
584500
}
585501

586502
#[test]
@@ -596,13 +512,16 @@ mod test {
596512
verbose: Verbosity<InfoLevel>,
597513
}
598514

599-
// round-trips
515+
// round-trips through serde. The default serialization is the uppercase name of the variant
516+
// as this is how log::LevelFilter is serialized.
600517
let toml = "meaning_of_life = 42\nverbose = \"DEBUG\"\n";
601518
let cli: Cli = toml::from_str(toml).unwrap();
602519
assert_eq!(cli.verbose.log_level_filter(), LevelFilter::Debug);
603520
assert_eq!(toml::to_string(&cli).unwrap(), toml);
604521

605-
// is case-insensitive
522+
// Checks that deserializing a lowercase level also works fine. Serializing is likely less
523+
// frequent than deserializing from a config file, so this is a more common case than the
524+
// above serialize then deserialize test.
606525
let toml = "meaning_of_life = 42\nverbose = \"debug\"\n";
607526
let cli: Cli = toml::from_str(toml).unwrap();
608527
assert_eq!(cli.verbose.log_level_filter(), LevelFilter::Debug);

0 commit comments

Comments
 (0)