demonstrate 0.4.5

Declarative testing framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Defines the inheritance behavior of `Describe` and `Test` block properties

use crate::block::{BasicBlock, BlockProps, Describe, DescribeProps, Test};

/// The trait and respective function for inheriting the parent `Describe` block's properties
pub(crate) trait Inherit {
    fn inherit(&mut self, parent_props: &DescribeProps);
}

impl Inherit for Describe {
    fn inherit(&mut self, parent_props: &DescribeProps) {
        // Inherit the `BlockProps` shared with `Test` blocks
        self.properties.block_props.inherit(parent_props);

        // Inherit `before` code sequences from parent
        if let Some(ref parent_props_before) = &parent_props.before {
            // Prepend parent_props's `before` code sequence
            let before = if let Some(ref self_before) = &self.properties.before {
                parent_props_before
                    .0
                    .iter()
                    .chain(self_before.0.iter())
                    .cloned()
                    .collect()
            } else {
                parent_props_before.0.clone()
            };

            self.properties.before = Some(BasicBlock(before));
        }

        // Inherit `after` code sequences from parent
        if let Some(ref parent_props_after) = &parent_props.after {
            // Append parent_props's `after` code sequence
            if let Some(ref mut self_after) = &mut self.properties.after {
                self_after.0.extend(parent_props_after.0.clone());
            } else {
                self.properties.after = Some(parent_props_after.clone());
            }
        }
    }
}

impl Inherit for Test {
    fn inherit(&mut self, parent_props: &DescribeProps) {
        // Inherit the `BlockProps` shared with `Describe` blocks
        self.properties.inherit(parent_props);

        // Append `before` code sequence from parent
        if let Some(ref parent_props_before) = &parent_props.before {
            self.content = BasicBlock(
                parent_props_before
                    .0
                    .iter()
                    .chain(self.content.0.iter())
                    .cloned()
                    .collect(),
            )
        }

        // Append `after` code sequence from parent
        if let Some(ref parent_props_after) = &parent_props.after {
            self.content.0.extend(parent_props_after.0.clone());
        }
    }
}

impl Inherit for BlockProps {
    fn inherit(&mut self, parent_props: &DescribeProps) {
        // Append attributes from parent
        self.attributes
            .extend(parent_props.block_props.attributes.clone());

        // If parent is async, so is self
        if !self.is_async && parent_props.block_props.is_async {
            self.is_async = true;
        }

        // If self doesn't have a return type, use its parent's
        if self.return_type.is_none() {
            self.return_type = parent_props.block_props.return_type.clone()
        }
    }
}