Module

# Test.PMock

- Package
- purescript-pmock
- Repository
- pujoheadsoft/purescript-pmock

### #CountVerifyMethod Source

`data CountVerifyMethod`

#### Constructors

#### Instances

`Show CountVerifyMethod`

`(Eq a) => VerifyCount CountVerifyMethod (Param a) a`

`VerifyCount CountVerifyMethod a a`

### #VerifyMatchType Source

`data VerifyMatchType a`

#### Constructors

#### Instances

`(Eq a, Show a) => Verify (Param a) (VerifyMatchType (Param a))`

`(Eq a, Show a) => Verify a (VerifyMatchType a)`

### #MockBuilder Source

`class MockBuilder params fun verifyParams | params -> fun, params -> verifyParams where`

#### Members

#### Instances

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g, Show h, Eq h, Show i, Eq i) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Cons (Param i) (Param r))))))))))) (a -> b -> c -> d -> e -> f -> g -> h -> i -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Param i)))))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g, Show h, Eq h) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Param r)))))))))) (a -> b -> c -> d -> e -> f -> g -> h -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Param h))))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Param r))))))))) (a -> b -> c -> d -> e -> f -> g -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Param g)))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Param r)))))))) (a -> b -> c -> d -> e -> f -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Param f))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Param r))))))) (a -> b -> c -> d -> e -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Param e)))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Param r)))))) (a -> b -> c -> d -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Param d))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Cons (Param c) (Param r))))) (a -> b -> c -> r) (Cons (Param a) (Cons (Param b) (Param c)))`

`(Show a, Eq a, Show b, Eq b) => MockBuilder (Array (Cons (Param a) (Cons (Param b) (Param r)))) (a -> b -> r) (Cons (Param a) (Param b))`

`(Show a, Eq a) => MockBuilder (Array (Cons (Param a) (Param r))) (a -> r) (Param a)`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g, Show h, Eq h, Show i, Eq i) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Cons (Param i) (Param r)))))))))) (a -> b -> c -> d -> e -> f -> g -> h -> i -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Param i)))))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g, Show h, Eq h) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Cons (Param h) (Param r))))))))) (a -> b -> c -> d -> e -> f -> g -> h -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Param h))))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f, Show g, Eq g) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Cons (Param g) (Param r)))))))) (a -> b -> c -> d -> e -> f -> g -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Param g)))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e, Show f, Eq f) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Cons (Param f) (Param r))))))) (a -> b -> c -> d -> e -> f -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Param f))))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d, Show e, Eq e) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Cons (Param e) (Param r)))))) (a -> b -> c -> d -> e -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Param e)))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c, Show d, Eq d) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Cons (Param d) (Param r))))) (a -> b -> c -> d -> r) (Cons (Param a) (Cons (Param b) (Cons (Param c) (Param d))))`

`(Show a, Eq a, Show b, Eq b, Show c, Eq c) => MockBuilder (Cons (Param a) (Cons (Param b) (Cons (Param c) (Param r)))) (a -> b -> c -> r) (Cons (Param a) (Cons (Param b) (Param c)))`

`(Show a, Eq a, Show b, Eq b) => MockBuilder (Cons (Param a) (Cons (Param b) (Param r))) (a -> b -> r) (Cons (Param a) (Param b))`

`(Show a, Eq a) => MockBuilder (Cons (Param a) (Param r)) (a -> r) (Param a)`

### #VerifyCount Source

`class VerifyCount countType params a where`

#### Members

`verifyCount :: forall fun m. MonadThrow Error m => Eq params => Mock fun params -> countType -> a -> m Unit`

#### Instances

`(Eq a) => VerifyCount CountVerifyMethod (Param a) a`

`(Eq a) => VerifyCount Int (Param a) a`

`VerifyCount CountVerifyMethod a a`

`VerifyCount Int a a`

### #VerifyOrder Source

`class VerifyOrder params input where`

#### Members

`verifySequence :: forall fun m. MonadThrow Error m => Mock fun params -> Array input -> m Unit`

`verifyPartiallySequence :: forall fun m. MonadThrow Error m => Mock fun params -> Array input -> m Unit`

#### Instances

`(Eq a, Show a) => VerifyOrder (Param a) a`

`(Eq a, Show a) => VerifyOrder a a`

### #mock Source

`mock :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => params -> m (Mock fun verifyParams)`

### #namedMock Source

`namedMock :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => MockName -> params -> m (Mock fun verifyParams)`

### #mockFun Source

`mockFun :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => params -> m fun`

### #namedMockFun Source

`namedMockFun :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => String -> params -> m fun`

### #showCalledParams Source

`showCalledParams :: forall fun params. Show params => Mock fun params -> String`

### #hasBeenCalledWith Source

`hasBeenCalledWith :: forall @params @input fun m. Verify params input => MonadThrow Error m => Mock fun params -> input -> m Unit`

### #hasNotBeenCalledWith Source

`hasNotBeenCalledWith :: forall params a fun m. VerifyCount Int params a => MonadThrow Error m => Eq params => Mock fun params -> a -> m Unit`

### #hasBeenCalledTimes Source

`hasBeenCalledTimes :: forall @countType @params @a fun m. VerifyCount countType params a => MonadThrow Error m => Eq params => Mock fun params -> countType -> a -> m Unit`

### #hasBeenCalledTimesGreaterThanEqual Source

`hasBeenCalledTimesGreaterThanEqual :: forall params a fun m. VerifyCount CountVerifyMethod params a => MonadThrow Error m => Eq params => Mock fun params -> Int -> a -> m Unit`

### #hasBeenCalledTimesLessThanEqual Source

`hasBeenCalledTimesLessThanEqual :: forall params a fun m. VerifyCount CountVerifyMethod params a => MonadThrow Error m => Eq params => Mock fun params -> Int -> a -> m Unit`

### #hasBeenCalledTimesGreaterThan Source

`hasBeenCalledTimesGreaterThan :: forall params a fun m. VerifyCount CountVerifyMethod params a => MonadThrow Error m => Eq params => Mock fun params -> Int -> a -> m Unit`

### #hasBeenCalledTimesLessThan Source

`hasBeenCalledTimesLessThan :: forall params a fun m. VerifyCount CountVerifyMethod params a => MonadThrow Error m => Eq params => Mock fun params -> Int -> a -> m Unit`

### #hasBeenCalledInOrder Source

`hasBeenCalledInOrder :: forall @params @input fun m. VerifyOrder params input => MonadThrow Error m => Mock fun params -> Array input -> m Unit`

### #hasBeenCalledInPartialOrder Source

`hasBeenCalledInPartialOrder :: forall @params @input fun m. VerifyOrder params input => MonadThrow Error m => Mock fun params -> Array input -> m Unit`

## Re-exports from **Test.**PMock.Cons

## Re-exports from **Test.**PMock.Param

### #Param Source

`data Param v`

#### Constructors

#### Instances

`(Eq a) => Eq (Param a)`

`(Show a) => Show (Param a)`

`ConsGen (Cons a b) (Param b) (Cons (Cons a b) (Param b))`

`ConsGen (Param a) (Cons b c) (Cons (Param a) (Cons b c))`

`ConsGen a (Cons b c) (Cons (Param a) (Cons b c))`

`ConsGen (Cons a b) c (Cons (Cons a b) (Param c))`

`ConsGen (Param a) (Param b) (Cons (Param a) (Param b))`

`ConsGen a (Param b) (Cons (Param a) (Param b))`

`ConsGen (Param a) b (Cons (Param a) (Param b))`

`ConsGen a b (Cons (Param a) (Param b))`

`(Eq a, Show a) => NotMatcher (Param a) (Param a)`

`(Eq a, Show a) => NotMatcher a (Param a)`

`(Eq a, Show a) => LogicalMatcher (Param a) (Param a) (Param a)`

`(Eq a, Show a) => LogicalMatcher (Param a) a (Param a)`

`(Eq a, Show a) => LogicalMatcher a a (Param a)`

### #and Source

`and :: forall a b r. LogicalMatcher a b r => a -> b -> r`

### #notEqual Source

`notEqual :: forall a r. NotMatcher a r => a -> r`

### #or Source

`or :: forall a b r. LogicalMatcher a b r => a -> b -> r`