anchor.diff:      let handlers =
           EventfulHandlers.empty
           |> EventfulHandlers.addAggregate widgetHandlers
  +        |> EventfulHandlers.addAggregate widgetCounterAggregate
   
  -    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)
  +    let newSystem client = new EventStoreSystem(handlers, client, RunningTests.esSerializer)
   
       [<Fact>]
  +    [<Trait("requires", "eventstore")>]
       let ``Can run command`` () : unit =
           async {
               let! connection = RunningTests.getConnection()
  
positive.code:     ( 
          handlers : EventfulHandlers, 
          client : Client,
          serializer: ISerializer,
          eventTypeMap : Bimap<string, ComparableType>
      ) =
  
      member x.RunCommand (cmd : obj) = 
          async {
              let program = EventfulHandlers.getCommandProgram cmd handlers
              let! result = EventStreamInterpreter.interpret client serializer eventTypeMap program 
              return result
          }
  
  
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