Packages

purerl_test

0.1.10
0.1.10 0.1.9 0.1.8 0.1.6 0.1.5 0.1.4 0.1.3 0.1.2 0.1.1 0.1.0

A testing library for PureScript (`purerl`) projects.

HexDocs

Current section

Files

Jump to
Readme
10 Versions
2 Dependencies
Dependants
Files
Activity
purerl_test src PurerlTest Types.purs
Raw

src/PurerlTest/Types.purs 

module PurerlTest.Types

  ( TestResult(..)

  , AssertionFailure(..)

  , Suites

  , Suite(..)

  , SuiteName(..)

  , SuiteStatus(..)

  , Tests

  , Test(..)

  , TestName(..)

  , Assertions

  , Assertion(..)

  , AssertionResult(..)

  ) where



import Prelude



import Control.Monad.Reader (ReaderT)

import Data.Generic.Rep (class Generic)

import Data.Newtype (class Newtype)

import Data.Show.Generic (genericShow)

import Effect (Effect)

import Effect.Ref (Ref)

import Foreign (Foreign)



newtype SuiteName = SuiteName String



derive newtype instance Eq SuiteName

derive instance Newtype SuiteName _



newtype TestName = TestName String



derive newtype instance Eq TestName

derive instance Newtype TestName _



data TestResult

  = TestFailed { test :: TestName, failures :: Array AssertionFailure }

  | TestDone { test :: TestName }



data AssertionResult

  = AssertionPassed

  | AssertionFailed { index :: Int, message :: String }



derive instance Generic AssertionResult _



instance Show AssertionResult where

  show = genericShow



data SuiteStatus

  = SuiteStarted { name :: SuiteName }

  | SuiteDone { name :: SuiteName }



type AssertionFailure = { index :: Int, message :: String }



type Suite = { name :: SuiteName, tests :: Tests }



type Test = { name :: TestName, assertions :: Assertions }



type Tests = ReaderT (Ref (Array Test)) Effect Unit



type Suites = ReaderT (Ref (Array Suite)) Effect Unit



type Assertions = ReaderT (Ref (Array (Assertion Foreign))) Effect Unit



data Assertion a

  = Assert Boolean

  | Refute Boolean

  | AssertEqual { left :: a, right :: a }

  | AssertNotEqual { left :: a, right :: a }

  | AssertGreaterThan { left :: a, right :: a }

  | AssertLessThan { left :: a, right :: a }

  | AssertGreaterThanOrEqual { left :: a, right :: a }

  | AssertLessThanOrEqual { left :: a, right :: a }