anchor.diff:      ( 
           handlers : EventfulHandlers, 
           client : Client,
  -        serializer: ISerializer,
  -        eventTypeMap : Bimap<string, ComparableType>
  +        serializer: ISerializer
       ) =
   
       member x.RunCommand (cmd : obj) = 
           async {
               let program = EventfulHandlers.getCommandProgram cmd handlers
  -            let! result = EventStreamInterpreter.interpret client serializer eventTypeMap program 
  +            let! result = EventStreamInterpreter.interpret client serializer handlers.EventTypeMap program 
               return result
           }
   
  
positive.code:     let handlers =
          EventfulHandlers.empty
          |> EventfulHandlers.addAggregate widgetHandlers
  
      let typeMappings : Bimap<string, ComparableType> =
          Bimap<string, ComparableType>.Empty
          |> Bimap.addNew (typeof<WidgetCreatedEvent>.Name) (new ComparableType(typeof<WidgetCreatedEvent>))
  
      let newSystem client = new EventStoreSystem(handlers, client, RunningTests.esSerializer, typeMappings)
  
      [<Fact>]
      let ``Can run command`` () : unit =
          async {
              let! connection = RunningTests.getConnection()
  
negative.code:             let system = newSystem client
  
              let widgetId = { WidgetId.Id = Guid.NewGuid() }
              let! cmdResult = 
                  system.RunCommand
                      { 
                          CreateWidgetCommand.WidgetId = widgetId; 
                          Name = "Mine"
                      }
  
              let expectedStreamName = sprintf "Widget-%s" (widgetId.Id.ToString("N"))
  
              let expectedEvent = {
                  WidgetCreatedEvent.WidgetId = widgetId
                  Name = "Mine"
              }
  
              match cmdResult with
              | Choice1Of2 [(streamName, event, metadata)] ->
                  streamName |> should equal expectedStreamName
                  event |> should equal expectedEvent 
              | x ->
                  Assert.True(false, sprintf "Expected one success event instead of %A" x)
  
              return ()
          } |> Async.RunSynchronously