anchor.diff:              Expect.isGreaterThan (Seq.length findResult) 0 "Should have returned at least one record."
               Expect.all findResult (fun d -> d.Bat = expected) "Every returned doc should have a Bat property equal to the expected value."
           }
  +
  +        testCaseAsync "Can find values between int64" <| async {
  +            let expected = 1516395484000L
  +            let min = expected - 10000000000L
  +            let max = expected + 10000000000L
  +
  +            // Create records that would be under the min range, over the max range, and between both
  +            do! Async.Parallel [
  +                    create ({defaultRecord with Bat = min - 1L}) client
  +                    create ({defaultRecord with Bat = max + 1L}) client
  +                    create ({defaultRecord with Bat = expected - 1L}) client
  +                    create ({defaultRecord with Bat = expected + 1L}) client
  +                ]|> Async.Ignore
  +
  +            // let! result = findByExpr<MyTestClass> <@ fun (c: MyTestClass) -> c.Bat > min @> None client
  +            let selector = Map.ofSeq ["Bat", [GreaterThan min; LesserThan max]]
  +            let! result = findBySelector<MyTestClass> selector None client
  +
  +            Expect.all result (fun c -> c.Bat > min && c.Bat < max) "All records returned should be greater than min value and lesser than max value."
  +        }
  +
  +        testCaseAsync "Serializes and deserializes options and unions" <| async {
  +            let expectedOpt = None
  +            let expectedUnionStr = Case1 "testing union 1"
  +            let expectedUnionInt = Case2 42
  +            let expectedUnionInt64 = Case3 123456789L
  +            let expectedDate = DateTime.UtcNow.AddHours -7.
  +            let expectedDecimal = 23.75M
  +
  +            let! createdOpt = create ({ defaultRecord with Opt = expectedOpt }) client
  +            let! createdUnionStr = create ({ defaultRecord with Union = expectedUnionStr }) client
  +            let! createdUnionInt = create ({defaultRecord with Union = expectedUnionInt }) client
  +            let! createdUnionInt64 = create ({defaultRecord with Union = expectedUnionInt64 }) client
  +            let! createdDateTime = create ({defaultRecord with Date = expectedDate}) client
  +            let! createdDecimal = create({defaultRecord with Dec = expectedDecimal}) client
  +
  +            let! opt = get createdOpt.Id (Some createdOpt.Rev) client |> asyncMap Option.get
  +            let! unionStr = get createdUnionStr.Id (Some createdUnionStr.Rev) client |> asyncMap Option.get
  +            let! unionInt = get createdUnionInt.Id (Some createdUnionInt.Rev) client |> asyncMap Option.get
  +            let! unionInt64 = get createdUnionInt64.Id (Some createdUnionInt64.Rev) client |> asyncMap Option.get
  +            let! dateTime = get createdDateTime.Id (Some createdDateTime.Rev) client |> asyncMap Option.get
  +            let! decimal = get createdDecimal.Id (Some createdDecimal.Rev) client |> asyncMap Option.get
  +
  +            Expect.equal opt.Opt expectedOpt "Options should be equal"
  +            Expect.equal unionStr.Union expectedUnionStr "Union str should be equal"
  +            Expect.equal unionInt.Union expectedUnionInt "Union int should be equal"
  +            Expect.equal unionInt64.Union expectedUnionInt64 "Union int64 should be equal"
  +            Expect.equal dateTime.Date expectedDate "Date should be equal"
  +            Expect.equal decimal.Dec expectedDecimal "Decimal should be equal"
  +        }
       ]
positive.code:             do! create ({defaultRecord with Foo = expected}) client |> Async.Ignore
              do! create defaultRecord client |> Async.Ignore
  
              let map = Map.ofSeq ["Foo", NotEqualTo expected]
              let! found = findBySelector<MyTestClass> map None client
  
              Expect.isNonEmpty map "findByMap should have found at least one doc."
  
negative.code:     |> designDoc designDocName
      |> toSeq
  
  let notNullOrEmpty (s: string) = String.IsNullOrEmpty s |> Expect.isFalse
  
  let asyncMap (fn: 'a -> 'b) (task: Async<'a>) = async {
  