Test.Spec.Tree

type ActionWith :: (Type -> Type) -> Type -> Typetype ActionWith m a = a -> m Unit

newtype Item :: (Type -> Type) -> Type -> Typenewtype Item m a

Constructors

• Item { example :: (ActionWith m a -> m Unit) -> m Unit, isFocused :: Boolean, isParallelizable :: Maybe Boolean }

Instances

• Newtype (Item m a) _
• Show (Item m a)
• Eq (Item m a)

type Path = Array PathItem

newtype PathItem

Constructors

• PathItem { index :: Int, name :: Maybe String }

Instances

• Newtype PathItem _
• Show PathItem
• Eq PathItem
• Ord PathItem

data Tree n c a

Constructors

• Node (Either n c) (Array (Tree n c a))
• Leaf n (Maybe a)

Instances

• Functor (Tree n c)
• (Show c, Show a, Show n) => Show (Tree n c a)
• (Eq c, Eq a, Eq name) => Eq (Tree name c a)
• Bifunctor (Tree n)
• Foldable (Tree n c)

annotateWithPaths :: forall c a. Array (Tree String c a) -> Array (Tree (String /\ Path) c a)

bimapTreeWithPaths :: forall a b c d n. (Array n -> a -> b) -> (NonEmptyArray n -> c -> d) -> Tree n a c -> Tree n b d

countTests :: forall n c t. Array (Tree n c t) -> Int

Count the total number of tests in a spec

discardUnfocused :: forall n c m a. Array (Tree n c (Item m a)) -> Array (Tree n c (Item m a))

If there is at least one focused element, all paths which don't lead to a focused element will be remove. otherwise input will be returned as unchanged.

filterTree :: forall n c a. (n -> Maybe a -> Boolean) -> Tree n c a -> Maybe (Tree n c a)

filterTrees :: forall n c a. (n -> Maybe a -> Boolean) -> Array (Tree n c a) -> Array (Tree n c a)

isAllParallelizable :: forall n c m a. Tree n c (Item m a) -> Boolean

Return true if all items in the tree are parallelizable

mapTreeAnnotations :: forall n m c a. (n -> m) -> Tree n c a -> Tree m c a

modifyAroundAction :: forall g a b. (ActionWith g a -> ActionWith g b) -> Item g a -> Item g b

Modify around action of an Item

parentSuite :: Path -> Maybe { name :: String, path :: Path }

parentSuiteName :: Path -> Array String