generate a method from Mock DSL. Mock DSL consists of rules. On a call of generated method, the first rule matched the arguments is applied.

Specify behavior that return a constant value for a call

Specify behavior that executes an action for a call

Specify behavior from a pair of a condition and a method.

throwNoStubWithShow fshow matcher means the method raises runtime exception if the arguments matches matcher. The argument tuple is converted to String by using fshow function.

throwNoStub matcher means the method raises a runtime exception if the arguments matches matcher. The argument tuple is converted to String by using show function.

Dynamic value whose content is showable. Using this type instead of Dynamic is recommended because it gives better error messages.

A value of type Dynamic is an object encapsulated together with its type.

A Dynamic may only represent a monomorphic value; an attempt to create a value of type Dynamic from a polymorphically-typed expression will result in an ambiguity error (see toDyn).

Showing a value of type Dynamic returns a pretty-printed representation of the object's type; useful for debugging.

convert a dynamically-typed method to a polymorphic method.

  fDyn :: String -> DynamicShow -> Dynamic -> IO [DynamicShow]
  fDyn = ...
  fPoly :: (Typeable a, Show a, Typeable b, Typeable c, Show c) => String -> a -> b -> IO [c]
  fPoly = castMethod fDyn
  

Convert given matcher to dynamic matcher. The dynamic matcher matches a dynamic value only if the value has the type of given matcher.

FromDyn a b provides a function to convert type a to type b, where b is a type whose dynamic type occurences are replaced by concrete types.

For example: FromDyn (Int, Dynamic, Maybe Dynamic) (Int, Bool, Maybe String)

ToDyn a b provides a function to convert type b to type a, where b is a type whose dynamic type occurences are replaced by concrete types.

For example: ToDyn (Int, Dynamic, Maybe Dynamic) (Int, Bool, Maybe String)

The class Typeable allows a concrete representation of a type to be calculated.

Monitor arg ret is an event monitor of methods, which logs method calls.

Event args ret is a function call event

watchBy fArgs fRet monitor method decorates method so that monitor logs the method calls. This function is suited for monitoring multiple methods.

fArgs and fRet is converter for arguments/return values of given method.

foo :: Int -> IO String
foo = ...
bar :: Int -> String -> IO ()
bar = ...

data MonitorArgs = FooArgs Int | BarArgs (Int,String) deriving(Eq,Show)
data MonitorRet = FooRet String | BarRet () deriving(Eq, Show)

foo' :: Monitor MonitorArgs MonitorRet -> Int -> IO String
foo' monitor = watch monitor (FooArgs . toTuple) FooRet foo
bar' :: Monitor MonitorArgs MonitorRet -> Int -> String -> IO ()
bar' monitor = watch monitor (BarArgs . toTuple) BarRet bar

Simplified version of watchBy. It is suitable to monitor single method.

withMonitor f calls f with Monitor, and then returns monitored event logs during the function call in addition to the return value of the function call

withMonitor_ f calls f with Monitor, and returns event logs during the call.

call matcher matches method call whose arguments matches matcher

times countMatcher eventMatcher counts events that matches eventMatcher, and then the count matches countMatcher

Generate new instance of Monitor

Get current event logs from monitor

Build ProtocolEnv from Protocol DSL.

withProtocol proto action executes action with a mock interface specified by proto, and then, it calls verify.

ProtocolEnv f provides mock methods, where f is a GADT functor that represents the set of dependent methods.

Generate the label type from given interface type.

• Define GADT XXXLabel m for interface XXX.

  • FieldX :: XXXLabel X for each field fieldX :: X where X is a standard type.

  • PolyFieldX :: XXXLabel ty[Dynamic/a] for each field of the form polyFieldX :: (forall a. Typeable a => ty)

    • Type variable a is substituted with DynamicShow if a is instances of Show and Typeable
    • Type variable a is substituted with Dynamic if a is an instance of Typeable but not Show
    • Report an error if type variable a is not an instance of Typeable
• Define instance Label XXXLabel.

Example

data API env = API {
    _foo :: Int -> RIO env Int,
    _bar :: forall a. (Show a, Typeable a) => String -> RIO env (Maybe a),
    _baz :: forall b. (Typeable a) => b -> RIO env ()
  }

deriveLabel ''API will generate the following code.

data APILabel env m where
    Foo :: APILabel env (Int -> RIO env Int)
    Bar :: APILabel env (String -> RIO env (Maybe DynamicShow)) -- type variable `a` is replaced with DynamicShow
    Baz :: APILabel env (Dynamic -> RIO env ()) -- type variable 'b' is replaced with Dynamic

instance Label (APILabel env) where
    type InterfaceOf (APILabel env) = API env
    toInterface k = API (k Foo) (castMethod (k Bar)) (castMethod (k Baz))
    showLabel x = case x of
      Foo -> Foo
      Bar -> Bar
      Baz -> Baz

f :|: g is the disjoint union of label f and label g. Use this type when you want to specify a protocol for multiple interfaces.

Example

data FooService = FooService {
  foo :: Int -> IO Bool,
  ...
  }
data BarService = BarService {
  bar :: String -> IO (),
  ...
  }
deriveLabel ''FooService
deriveLabel ''BarService

proto :: ProtocolM (FooServiceLabel :|: BarServiceLabel) ()
proto = do
  i1 <- decl $ whenArgs (L Foo) (==1) `thenReturn` True
  void $ decl $ whenArgs (R Bar) (=="bar") `thenReturn` () `dependsOn` [i1]

main :: IO ()
main = withProtocol proto $ \(fooService, barService) -> do
  ...

Declare a method call specification. It returns the call id of the method call.

Specify the argument condition of a method call

Specify on which method calls the call depends.

Get the mock interface from ProtocolEnv

Get the mock method by method name. Return a unstubed method (which throws exception for every call) if the behavior of the method is unspecified by ProtocolEnv

Get the mock method by method name. Return a unstubed method (which throws exception for every call) if the behavior of the method is unspecified by ProtocolEnv. Use this function only if you want to customize show implementation for the argument of the method.

Verify that all method calls specified by Protocol DSL are fired.

Matcher that matches anything

synonym of id function. Use this function for improving readability

Matcher for Args

>>> args ((==2), (>3)) (2 :* 4 :* Nil)
True
>>> args even (1 :* Nil)
False
>>> args () Nil
True

Convert a tuple matcher to a tuple-like matcher.

>>> args' (\(a, b) -> a * b == 10) (2 :* 5 :* Nil)
True
>>> args' (\(a, b) -> a * b == 10) (2 :* 4 :* Nil)
False