Struct spectral::Spec

pub struct Spec<'s, S: 's> {
    pub subject: &'s S,
    pub subject_name: Option<&'s str>,
    pub location: Option<String>,
    pub description: Option<&'s str>,
}

An assertion.

This is created by either the assert_that function, or by calling that on a SpecDescription.

Fields

subject: &'s S

subject_name: Option<&'s str>

location: Option<String>

description: Option<&'s str>

Methods

impl<'s, S> Spec<'s, S>

fn at_location(self, location: String) -> Self

Provides the actual location of the assertion.

Usually you would not call this directly, but use the macro forms of assert_that and asserting, which will call this on your behalf with the correct location.

fn named(self, subject_name: &'s str) -> Self

Associates a name with the subject.

This will be displayed if the assertion fails.

impl<'s, S> Spec<'s, S> where
    S: Debug + PartialEq, 

fn is_equal_to<E: Borrow<S>>(&mut self, expected: E)

Asserts that the actual value and the expected value are equal. The value type must implement PartialEq.

assert_that(&"hello").is_equal_to(&"hello");

fn is_not_equal_to<E: Borrow<S>>(&mut self, expected: E)

Asserts that the actual value and the expected value are not equal. The value type must implement PartialEq.

assert_that(&"hello").is_not_equal_to(&"hello");

impl<'s, S> Spec<'s, S> where
    S: Debug, 

fn matches<F>(&mut self, matching_function: F) where
    F: Fn(&'s S) -> bool, 

Accepts a function accepting the value type which returns a bool. Returning false will cause the assertion to fail.

NOTE: The resultant panic message will only state the actual value. It's recommended that you write your own assertion rather than relying upon this.

assert_that(&"hello").matches(|x| x.eq(&"hello"));

fn map<F, T>(self, mapping_function: F) -> Spec<'s, T> where
    F: Fn(&'s S) -> &'s T, 

Transforms the subject of the Spec by passing it through to the provided mapping function.

let test_struct = TestStruct { value: 5 };
assert_that(&test_struct).map(|val| &val.value).is_equal_to(&5);

Trait Implementations

impl<'s> BooleanAssertions for Spec<'s, bool>

fn is_true(&mut self)

Asserts that the subject is true. The subject type must be bool.

assert_that(&true).is_true();

fn is_false(&mut self)

Asserts that the subject is false. The subject type must be bool.

assert_that(&true).is_false();

impl<'s, K, V> HashMapAssertions<'s, K, V> for Spec<'s, HashMap<K, V>> where
    K: Hash + Eq + Debug,
    V: PartialEq + Debug, 

fn has_length(&mut self, expected: usize)

Asserts that the length of the subject hashmap is equal to the provided length. The subject type must be of HashMap.

let mut test_map = HashMap::new();
test_map.insert(1, 1);
test_map.insert(2, 2);

assert_that(&test_map).has_length(2);

fn is_empty(&mut self)

Asserts that the subject hashmap is empty. The subject type must be of HashMap.

let test_map: HashMap<u8, u8> = HashMap::new();
assert_that(&test_map).is_empty();

fn contains_key<E: Borrow<K>>(&mut self, expected_key: E) -> Spec<'s, V>

Asserts that the subject hashmap contains the expected key. The subject type must be of HashMap.

This will return a new Spec containing the associated value if the key is present.

let mut test_map = HashMap::new();
test_map.insert("hello", "hi");

assert_that(&test_map).contains_key(&"hello");

fn does_not_contain_key<E: Borrow<K>>(&mut self, expected_key: E)

Asserts that the subject hashmap does not contain the provided key. The subject type must be of HashMap.

let mut test_map = HashMap::new();
test_map.insert("hello", "hi");

assert_that(&test_map).does_not_contain_key(&"hey");

fn contains_entry<E: Borrow<K>, F: Borrow<V>>(
    &mut self,
    expected_key: E,
    expected_value: F
)

Asserts that the subject hashmap contains the expected key with the expected value. The subject type must be of HashMap.

let mut test_map = HashMap::new();
test_map.insert("hello", "hi");

assert_that(&test_map).contains_entry(&"hello", &"hi");

fn does_not_contain_entry<E: Borrow<K>, F: Borrow<V>>(
    &mut self,
    expected_key: E,
    expected_value: F
)

Asserts that the subject hashmap does not contains the provided key and value. The subject type must be of HashMap.

let mut test_map = HashMap::new();
test_map.insert("hello", "hi");

assert_that(&test_map).does_not_contain_entry(&"hello", &"hey");

impl<'s, T> OrderedAssertions<T> for Spec<'s, T> where
    T: Debug + PartialOrd, 

fn is_less_than<E: Borrow<T>>(&mut self, other: E)

Asserts that the subject is less than the expected value. The subject type must implement PartialOrd.

assert_that(&1).is_less_than(&2);

fn is_less_than_or_equal_to<E: Borrow<T>>(&mut self, other: E)

Asserts that the subject is less than or equal to the expected value. The subject type must implement PartialOrd.

assert_that(&2).is_less_than_or_equal_to(&2);

fn is_greater_than<E: Borrow<T>>(&mut self, other: E)

Asserts that the subject is greater than the expected value. The subject type must implement PartialOrd.

assert_that(&2).is_greater_than(&1);

fn is_greater_than_or_equal_to<E: Borrow<T>>(&mut self, other: E)

Asserts that the subject is greater than or equal to the expected value. The subject type must implement PartialOrd.

assert_that(&2).is_greater_than_or_equal_to(&1);

impl<'s, T: Float + Debug> FloatAssertions<T> for Spec<'s, T>

fn is_close_to<E: Borrow<T>, O: Borrow<T>>(&mut self, expected: E, tolerance: O)

Asserts that the subject is close to the expected value by the specified tolerance. The subject type must implement Float and Debug.

assert_that(&2.0f64).is_close_to(2.0f64, 0.01f64);

impl<'s, T> ContainingOptionAssertions<T> for Spec<'s, Option<T>> where
    T: Debug + PartialEq, 

fn contains_value<E: Borrow<T>>(&mut self, expected_value: E)

Asserts that the subject is a Some containing the expected value. The subject type must be an Option.

assert_that(&Some(1)).contains_value(&1);

impl<'s, T> OptionAssertions<'s, T> for Spec<'s, Option<T>> where
    T: Debug, 

fn is_some(&mut self) -> Spec<'s, T>

Asserts that the subject is Some. The subject type must be an Option.

This will return a new Spec containing the unwrapped value if it is Some.

assert_that(&Some(1)).is_some();

fn is_none(&mut self)

Asserts that the subject is None. The value type must be an Option.

assert_that(&Option::None::<String>).is_none();

impl<'s> PathAssertions for Spec<'s, &'s Path>

fn exists(&mut self)

Asserts that the subject Path refers to an existing location.

assert_that(&Path::new("/tmp/file")).exists();

fn does_not_exist(&mut self)

Asserts that the subject Path does not refer to an existing location.

assert_that(&Path::new("/tmp/file")).does_not_exist();

fn is_a_file(&mut self)

Asserts that the subject Path refers to an existing file.

assert_that(&Path::new("/tmp/file")).is_a_file();

fn is_a_directory(&mut self)

Asserts that the subject Path refers to an existing directory.

assert_that(&Path::new("/tmp/dir/")).is_a_directory();

fn has_file_name<'r, E: Borrow<&'r str>>(&mut self, expected_file_name: E)

Asserts that the subject Path has the expected file name.

assert_that(&Path::new("/tmp/file")).has_file_name(&"file");

impl<'s> PathAssertions for Spec<'s, PathBuf>

fn exists(&mut self)

Asserts that the subject PathBuf refers to an existing location.

assert_that(&PathBuf::from("/tmp/file")).exists();

fn does_not_exist(&mut self)

Asserts that the subject PathBuf does not refer to an existing location.

assert_that(&PathBuf::from("/tmp/file")).does_not_exist();

fn is_a_file(&mut self)

Asserts that the subject PathBuf refers to an existing file.

assert_that(&PathBuf::from("/tmp/file")).is_a_file();

fn is_a_directory(&mut self)

Asserts that the subject PathBuf refers to an existing directory.

assert_that(&PathBuf::from("/tmp/dir/")).is_a_directory();

fn has_file_name<'r, E: Borrow<&'r str>>(&mut self, expected_file_name: E)

Asserts that the subject PathBuf has the expected file name.

assert_that(&PathBuf::from("/tmp/file")).has_file_name(&"file");

impl<'s, T, E> ContainingResultAssertions<T, E> for Spec<'s, Result<T, E>> where
    T: Debug,
    E: Debug, 

fn is_ok_containing<V: Borrow<T>>(&mut self, expected_value: V) where
    T: PartialEq, 

Asserts that the subject is an Ok Result containing the expected value. The subject type must be a Result.

assert_that(&Result::Ok::<usize, usize>(1)).is_ok_containing(&1);

fn is_err_containing<V: Borrow<E>>(&mut self, expected_value: V) where
    E: PartialEq, 

Asserts that the subject is an Err Result containing the expected value. The subject type must be a Result.

assert_that(&Result::Err::<usize, usize>(1)).is_err_containing(&1);

impl<'s, T, E> ResultAssertions<'s, T, E> for Spec<'s, Result<T, E>> where
    T: Debug,
    E: Debug, 

fn is_ok(&mut self) -> Spec<'s, T>

Asserts that the subject is Ok. The value type must be a Result.

This will return a new Spec containing the unwrapped value if it is Ok.

assert_that(&Result::Ok::<usize, usize>(1)).is_ok();

fn is_err(&mut self) -> Spec<'s, E>

Asserts that the subject is Err. The value type must be a Result.

This will return a new Spec containing the unwrapped value if it is Err.

assert_that(&Result::Err::<usize, usize>(1)).is_err();

impl<'s> StrAssertions for Spec<'s, &'s str>

fn starts_with<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject &str starts with the provided &str.

assert_that(&"Hello").starts_with(&"H");

fn ends_with<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject &str ends with the provided &str.

assert_that(&"Hello").ends_with(&"o");

fn contains<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject &str contains the provided &str.

assert_that(&"Hello").contains(&"e");

impl<'s> StrAssertions for Spec<'s, String>

fn starts_with<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject String starts with the provided &str.

assert_that(&"Hello".to_owned()).starts_with(&"H");

fn ends_with<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject String ends with the provided &str.

assert_that(&"Hello".to_owned()).ends_with(&"o");

fn contains<'r, E: Borrow<&'r str>>(&mut self, expected: E)

Asserts that the subject String contains the provided &str.

assert_that(&"Hello".to_owned()).contains(&"e");

impl<'s, T> VecAssertions for Spec<'s, Vec<T>>

fn has_length(&mut self, expected: usize)

Asserts that the length of the subject vector is equal to the provided length. The subject type must be of Vec.

assert_that(&vec![1, 2, 3, 4]).has_length(4);

fn is_empty(&mut self)

Asserts that the subject vector is empty. The subject type must be of Vec.

let test_vec: Vec<u8> = vec![];
assert_that(&test_vec).is_empty();

impl<'s, T: 's, I> ContainingIntoIterAssertions<'s, T> for Spec<'s, I> where
    T: Debug + PartialEq,
    &'s I: IntoIterator<Item = &'s T>, 

fn contains<E: 's + Borrow<T>>(&mut self, expected_value: E)

Asserts that the subject contains the provided value. The subject must implement IntoIterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec).contains(&2);

fn contains_all_of<E: 's>(&mut self, expected_values_iter: &'s E) where
    E: IntoIterator<Item = &'s T> + Clone, 

Asserts that the subject contains all of the provided values. The subject must implement IntoIterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec).contains_all_of(&vec![2, 3]);

fn does_not_contain<E: 's + Borrow<T>>(&mut self, expected_value: E)

Asserts that the subject does not contain the provided value. The subject must implement IntoIterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec).does_not_contain(&4);

fn equals_iterator<E: 's>(&mut self, expected_iter: &'s E) where
    E: Iterator<Item = &'s T> + Clone, 

Asserts that the subject is equal to provided iterator. The subject must implement IntoIterator, the contained type must implement PartialEq and Debug and the expected value must implement Iterator and Clone.

let expected_vec = vec![1,2,3];
let test_vec = vec![1,2,3];
assert_that(&test_vec).equals_iterator(&expected_vec.iter());

impl<'s, T: 's, I> ContainingIteratorAssertions<'s, T> for Spec<'s, I> where
    T: Debug + PartialEq,
    I: Iterator<Item = &'s T> + Clone, 

fn contains<E: 's + Borrow<T>>(&mut self, expected_value: E)

Asserts that the iterable subject contains the provided value. The subject must implement Iterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec.iter()).contains(&2);

fn contains_all_of<E: 's>(&mut self, expected_values_iter: &'s E) where
    E: IntoIterator<Item = &'s T> + Clone, 

Asserts that the subject contains all of the provided values. The subject must implement Iterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec.iter()).contains_all_of(&vec![2, 3]);

fn does_not_contain<E: 's + Borrow<T>>(&mut self, expected_value: E)

Asserts that the iterable subject does not contain the provided value. The subject must implement Iterator, and the contained type must implement PartialEq and Debug.

let test_vec = vec![1,2,3];
assert_that(&test_vec.iter()).does_not_contain(&4);

fn equals_iterator<E: 's>(&mut self, expected_iter: &'s E) where
    E: Iterator<Item = &'s T> + Clone, 

Asserts that the iterable subject is equal to provided iterator. The subject must implement Iterator, the contained type must implement PartialEq and Debug and the expected value must implement Iterator and Clone.

let expected_vec = vec![1,2,3];
let test_vec = vec![1,2,3];
assert_that(&test_vec.iter()).equals_iterator(&expected_vec.iter());

impl<'s, T: 's, I> MappingIterAssertions<'s, T> for Spec<'s, I> where
    T: Debug,
    &'s I: IntoIterator<Item = &'s T>, 

fn mapped_contains<F, M: 's>(&mut self, mapping_function: F, expected_value: &M) where
    M: Debug + PartialEq,
    F: Fn(&'s T) -> M, 

Maps the values of the subject before asserting that the mapped subject contains the provided value. The subject must implement IntoIterator, and the type of the mapped value must implement PartialEq.

NOTE: The panic message will refer to the mapped values rather than the values present in the original subject.

#[derive(PartialEq, Debug)]
struct Simple {
    pub val: usize,
}

...

assert_that(&vec![Simple { val: 1 }, Simple { val: 2 } ]).mapped_contains(|x| &x.val, &2);

fn matching_contains<F>(&mut self, matcher: F) where
    F: Fn(&'s T) -> bool, 

Asserts that the subject contains a matching item by using the provided function. The subject must implement IntoIterator, and the contained type must implement Debug.

let mut test_into_iter = LinkedList::new();
test_into_iter.push_back(TestEnum::Bad);
test_into_iter.push_back(TestEnum::Good);
test_into_iter.push_back(TestEnum::Bad);

assert_that(&test_into_iter).matching_contains(|val| {
    match val {
        &TestEnum::Good => true,
        _ => false
    }
});

impl<'s, S: Debug + 's> Debug for Spec<'s, S>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'r, T> DescriptiveSpec<'r> for Spec<'r, T>

fn subject_name(&self) -> Option<&'r str>

fn location(&self) -> Option<String>

fn description(&self) -> Option<&'r str>