Yoga.Om.Test

describe :: forall ctx. String -> Aff ctx -> SpecOm ctx Unit -> Spec Unit

it :: forall ctx. String -> Om ctx () Unit -> SpecOm ctx Unit

itWith :: forall ctx ctx'. String -> Aff ctx' -> Om ctx' () Unit -> SpecOm ctx Unit

testOm :: forall ctx a. Monoid a => ctx -> Om ctx () a -> Aff a

fail :: forall m. MonadEffect m => String -> m Unit

shouldEqual :: forall m t. MonadEffect m => Show t => Eq t => t -> t -> m Unit

shouldNotEqual :: forall m t. MonadEffect m => Show t => Eq t => t -> t -> m Unit

shouldSatisfy :: forall m t. MonadEffect m => Show t => t -> (t -> Boolean) -> m Unit

shouldNotSatisfy :: forall m t. MonadEffect m => Show t => t -> (t -> Boolean) -> m Unit

shouldContain :: forall m f a. MonadEffect m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

shouldNotContain :: forall m f a. MonadEffect m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

textContentShouldEqual :: forall m. MonadEffect m => HTMLElement -> String -> m Unit

newtype SpecT :: (Type -> Type) -> Type -> (Type -> Type) -> Type -> Typenewtype SpecT g i m a

Instances

• Newtype (SpecT g i m a) _
• (Functor m) => Functor (SpecT g i m)
• (Apply m) => Apply (SpecT g i m)
• (Applicative m) => Applicative (SpecT g i m)
• (Alt m) => Alt (SpecT g i m)
• (Plus m) => Plus (SpecT g i m)
• (Alternative m) => Alternative (SpecT g i m)
• (Bind m) => Bind (SpecT g i m)
• (Monad m) => Monad (SpecT g i m)
• (MonadRec m) => MonadRec (SpecT g i m)
• (MonadPlus m) => MonadPlus (SpecT g i m)
• MonadTrans (SpecT g i)
• (MonadEffect m) => MonadEffect (SpecT g i m)
• (MonadCont m) => MonadCont (SpecT g i m)
• (MonadThrow e m) => MonadThrow e (SpecT g i m)
• (MonadError e m) => MonadError e (SpecT g i m)
• (MonadAsk r m) => MonadAsk r (SpecT g i m)
• (MonadReader r m) => MonadReader r (SpecT g i m)
• (MonadState s m) => MonadState s (SpecT g i m)

type Spec a = SpecT Aff Unit Identity a

sequential :: forall m g i a. Monad m => SpecT g i m a -> SpecT g i m a

marks all spec items of the given spec to be evaluated sequentially.

pending :: forall m g i. Monad m => String -> SpecT g i m Unit

Create a pending spec.

parallel :: forall m g i a. Monad m => SpecT g i m a -> SpecT g i m a

marks all spec items of the given spec to be safe for parallel evaluation.

focus :: forall m g i a. FocusWarning => Monad m => SpecT g i m a -> SpecT g i m a

focus focuses all spec items of the given spec.

Applying focus to a spec with focused spec items has no effect.

before_ :: forall m g i a. Monad m => Monad g => g Unit -> SpecT g i m a -> SpecT g i m a

Run a custom action before every spec item.

beforeAll_ :: forall m g i a. MonadEffect m => MonadAff g => MonadError Error g => g Unit -> SpecT g i m a -> SpecT g i m a

Run a custom action before the first spec item.

after_ :: forall m g e f i a. Monad m => MonadBracket e f g => g Unit -> SpecT g i m a -> SpecT g i m a

Run a custom action after every spec item.

afterAll_ :: forall m g i a. Monad m => g Unit -> SpecT g i m a -> SpecT g i m a

Run a custom action after the last spec item.