Enum contrafact::Check

pub enum Check {
    Failures(Vec<Failure>),
    Error(String),
}

The result of a check operation, which contains a failure message for every constraint which was not met.

There are two levels of “error” here: the failures due to data which does not meet the constraints, and also internal errors due to a poorly written Fact.

Variants

Failures(Vec<Failure>)

The check ran successfully, and reported these failures. An empty list of failures means the data is valid per this check.

Error(String)

There was a problem actually running the check: there is a bug in a Fact or Generator.

Implementations

impl Check

pub fn unwrap(self)

Panic if there are any errors, and display those errors.

pub fn is_ok(&self) -> bool

There are no errors.

pub fn is_err(&self) -> bool

There is at least one error.

pub fn failures(&self) -> Result<&[Failure], ContrafactError>

Get errors if they exist

pub fn result(self) -> ContrafactResult<Result<(), Vec<Failure>>>

Convert to a Result: No errors => Ok The result is wrapped in another Result, in case the overall check failed for an internal reason

use contrafact::*;
assert_eq!(Check::pass().result(), Ok(Ok(())));
assert_eq!(Check::fail("message").result(), Ok(Err(vec!["message".to_string()])));

pub fn check<S: ToString>(ok: bool, err: S) -> Self

Create a single-error failure if predicate is false, otherwise pass

use contrafact::*;
assert_eq!(Check::check(true, "message"), Check::pass());
assert_eq!(Check::check(false, "message"), Check::fail("message"));

pub fn from_mutation<T>(res: Mutation<T>) -> Self

Create a single-error failure from a Result

use contrafact::*;
assert_eq!(Check::from_mutation(Ok(42)), Check::pass());
assert_eq!(Check::from_mutation::<()>(Err(MutationError::Check("message".to_string()))), Check::fail("message"));

pub fn from_result(res: Result<Vec<Failure>, ContrafactError>) -> Self

Create a check where failures are drawn from Ok, and internal errors from Err of the input Result

pub fn pass() -> Self

Create an ok result.

use contrafact::*;
assert_eq!(Check::pass(), vec![].into())

pub fn fail<S: ToString>(error: S) -> Self

Create a failure result with a single error.

use contrafact::*;
assert_eq!(Check::fail("message"), vec!["message".to_string()].into())

Trait Implementations

impl Clone for Check

fn clone(&self) -> Check

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Check

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<String> for Check

fn from(original: String) -> Check

Converts to this type from the input type.

impl From<Vec<String, Global>> for Check

fn from(original: Vec<Failure>) -> Check

Converts to this type from the input type.

impl PartialEq<Check> for Check

fn eq(&self, other: &Check) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Check

impl StructuralEq for Check

impl StructuralPartialEq for Check