anchor.diff:              let system = newSystem client
   
               let widgetId = { WidgetId.Id = Guid.NewGuid() }
  -            let! ignored = 
  +            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
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 handlers =
          EventfulHandlers.empty
          |> EventfulHandlers.addAggregate widgetHandlers
          |> EventfulHandlers.addAggregate widgetCounterAggregate
  
      let newSystem client = new EventStoreSystem(handlers, client, RunningTests.esSerializer)
  
      [<Fact>]
      [<Trait("requires", "eventstore")>]
      let ``Can run command`` () : unit =
          async {
              let! connection = RunningTests.getConnection()
  