Struct spectral::Spec
[−]
[src]
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>
[src]
fn at_location(&mut self, location: String) -> &mut 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(&mut self, subject_name: &'s str) -> &mut 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
[src]
fn is_equal_to<E: Borrow<S>>(&mut self, expected: E) -> &mut Self
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) -> &mut Self
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
[src]
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>
[src]
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
[src]
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)
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)
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
[src]
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>
[src]
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
[src]
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
[src]
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>
[src]
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, T, E> ContainingResultAssertions<T, E> for Spec<'s, Result<T, E>> where T: Debug, E: Debug
[src]
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
[src]
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();
fn is_error(&mut self) -> Spec<'s, E>
: Please use is_err
instead as a direct replacement
DEPRECATED: Use is_err
instead to match standard Rust naming conventions.
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_error();
impl<'s> StrAssertions for Spec<'s, &'s str>
[src]
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, T> VecAssertions for Spec<'s, Vec<T>>
[src]
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>
[src]
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
[src]
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>
[src]
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 } });