anchor.diff:                  }) "Should be too many dogs!"
   
       }
  -    testCaseAsync', "exactlyOneAsync, Throws if none" ,
  -        fun db store -> async {
  +    testCaseAsync'
  +        "exactlyOneAsync, Throws if none" <|
  +        fun (db, store) -> async {
               do!
                   Expect.throwsTAsync<AggregateException>(async {
                       use session = store.OpenSession()
  
positive.code:                     |> Doc.head
                  Expect.isType<User> (box actualUser) "Should be User type"
                  Expect.equal expectedDog.Name actualUser.Name  "Should be a user!"
              }
  ]
  
  let headTests = [
      testCase', "head, single dog, Get Record Back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              use session = store.OpenSession()
              let actualDog =
                  session
                  |> Doc.query<Dog>
                  |> Doc.head
              Expect.equal expectedDog actualDog  "Should be a same dog!"
          }
      testCase', "head, multiple dogs, get top record back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              let _ = saveDog' store
              use session = store.OpenSession()
              let actualDog =
                  session
                  |> Doc.query<Dog>
                  |> Doc.head
              Expect.equal expectedDog actualDog  "Should be a same dog!"
          }
      testCase', "head, no dogs, throws exception" ,
          fun db store -> async {
              Expect.throwsT<InvalidOperationException>(fun _ ->
              use session = store.OpenSession()
              let actualDog =
                  session
                      |> Doc.query<Dog>
                      |> Doc.head
              ()
              ) "Should be no dog!"
          }
  
      testCaseAsync', "headAsync, single dog, Get Record Back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              use session = store.OpenSession()
              let! actualDog =
                  session
                  |> Doc.query<Dog>
                  |> Doc.headAsync
              Expect.equal expectedDog actualDog  "Should be a same dog!"
          }
      testCaseAsync', "headAsync, multiple dogs, get top record back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              let _ = saveDog' store
              use session = store.OpenSession()
              let! actualDog =
                  session
                  |> Doc.query<Dog>
                  |> Doc.headAsync
              Expect.equal expectedDog actualDog  "Should be a same dog!"
          }
      testCaseAsync', "headAsync, no dogs, throws exception" ,
          fun db store -> async {
              do!
                  Expect.throwsTAsync<AggregateException>(async {
                      use session = store.OpenSession()
                      let! actualDog =
                          session
                              |> Doc.query<Dog>
                              |> Doc.headAsync
                      ()
                  }) "Should be no dog!"
          }
  ]
  
  
  let toListTests = [
      testCase', "toList, single dog, get single back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              use session = store.OpenSession()
              let actualDogs =
                  session
                  |> Doc.query<Dog>
                  |> Doc.toList
              Expect.contains actualDogs expectedDog "Should contain same dog!"
          }
      testCase', "toList, multiple dogs, get multple back" ,
          fun db store -> async {
              let expectedDog = saveDog' store
              let expectedDog2 = saveDog' store
              use session = store.OpenSession()
  
negative.code: ]
  
  let filterTests = [
      testCase'
          "filter by, Get Record Back" <|
              fun (db, store) ->
                  let expectedDog = saveDog' store
                  use session = store.OpenSession()
                  let actualDog =
  