Expand Cosmos Emulator tests and harden read extension validation

src/Cosmos/Cosmos.fs

@@ -70,13 +70,22 @@ module Operations =
 
     type ItemRequestOptions with
 
+        /// <summary>
+        /// Adds a pre-trigger to request options.
+        /// </summary>
+        /// <param name="trigger">Trigger name.</param>
         member options.AddPreTrigger (trigger : string) =
             options.PreTriggers <- [|
                 if not <| isNull options.PreTriggers then
                     yield! options.PreTriggers
                 yield trigger
             |]
 
+        /// <summary>
+        /// Adds pre-triggers to request options.
+        /// </summary>
+        /// <param name="triggers">Trigger names.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="triggers"/> is <c>null</c>.</exception>
         member options.AddPreTriggers (triggers : string seq) =
             if obj.ReferenceEquals (triggers, null) then
                 raise (ArgumentNullException (nameof triggers))
@@ -93,6 +102,11 @@ module Operations =
                 yield trigger
             |]
 
+        /// <summary>
+        /// Adds post-triggers to request options.
+        /// </summary>
+        /// <param name="triggers">Trigger names.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="triggers"/> is <c>null</c>.</exception>
         member options.AddPostTriggers (triggers : string seq) =
             if obj.ReferenceEquals (triggers, null) then
                 raise (ArgumentNullException (nameof triggers))
@@ -211,25 +225,55 @@ module Operations =
         /// <summary>
         /// Checks if an item with specified Id exists in the container partition with specified key.
         /// </summary>
+        /// <param name="deletedFieldName">Deleted marker field name.</param>
         /// <param name="id">Item Id</param>
-        /// <param name="partitionKey">Partition key</param>
+        /// <param name="requestOptions">Request options</param>
         /// <param name="cancellationToken">Cancellation token</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="deletedFieldName"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException">
+        /// Thrown when <paramref name="deletedFieldName"/> does not start with a letter or underscore,
+        /// or contains characters other than letters, digits, or underscores.
+        /// </exception>
         member container.IsNotDeletedAsync
-            deletedFieldName
-            (id : string, [<Optional>] requiestOptions : QueryRequestOptions, [<Optional>] cancellationToken : CancellationToken)
+            (deletedFieldName : string)
+            (id : string, [<Optional>] requestOptions : QueryRequestOptions, [<Optional>] cancellationToken : CancellationToken)
             =
+            if obj.ReferenceEquals (deletedFieldName, null) then
+                nullArg (nameof deletedFieldName)
+
             task {
+                let isAsciiLetter c = ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
+                let isAsciiDigit c = '0' <= c && c <= '9'
+
+                let isValidDeletedFieldName =
+                    if String.IsNullOrWhiteSpace deletedFieldName then
+                        false
+                    else
+                        let firstCharacter = deletedFieldName[0]
+                        let hasValidStart = firstCharacter = '_' || isAsciiLetter firstCharacter
+                        let hasValidBody =
+                            deletedFieldName
+                            |> Seq.forall (fun c -> c = '_' || isAsciiLetter c || isAsciiDigit c)
+
+                        hasValidStart && hasValidBody
+
+                if not isValidDeletedFieldName then
+                    invalidArg
+                        (nameof deletedFieldName)
+                        "Deleted field name must start with a letter or underscore and contain only letters, digits, or underscores."
+
                 let query =
                     QueryDefinition(
-                        $"SELECT VALUE COUNT(1) \
-                     FROM item \
-                     WHERE item.id = @Id AND IS_NULL(item.{deletedFieldName})"
+                        $"""SELECT VALUE COUNT(1)
+                          FROM item
+                          WHERE item.id = @Id
+                          AND (NOT IS_DEFINED(item.{deletedFieldName}) OR IS_NULL(item.{deletedFieldName}))"""
                     )
                         .WithParameter ("@Id", id)
                 let! count =
                     container.GetItemQueryIterator<int> (
                         query,
-                        requestOptions = getRequestOptionsWithMaxItemCount1 requiestOptions
+                        requestOptions = getRequestOptionsWithMaxItemCount1 requestOptions
                     )
                     |> CancellableTaskSeq.ofFeedIterator cancellationToken
                     |> TaskSeq.tryHead

tests/Cosmos.Tests/Assert.fs

@@ -0,0 +1,72 @@
+namespace FSharp.Azure.Cosmos.Tests
+
+open System.Runtime.InteropServices
+open Microsoft.VisualStudio.TestTools.UnitTesting
+
+[<AutoOpen>]
+module AssertExtensions =
+
+    type Assert with
+
+        static member WantSome (value, [<Optional>] message : string | null) =
+            match value with
+            | Some some -> some
+            | None ->
+                Assert.Fail (message)
+                Unchecked.defaultof<_>
+
+        static member IsSome (value, [<Optional>] message : string | null) = Assert.WantSome (value, message) |> ignore
+
+        static member IsNone (value, [<Optional>] message : string | null) =
+            match value with
+            | Some _ -> Assert.Fail (message)
+            | None -> ()
+
+        static member WantValueSome (value, [<Optional>] message : string | null) =
+            match value with
+            | ValueSome some -> some
+            | ValueNone ->
+                Assert.Fail (message)
+                Unchecked.defaultof<_>
+
+        static member IsValueSome (value, [<Optional>] message : string | null) = Assert.WantValueSome (value, message) |> ignore
+
+        static member IsValueNone (value, [<Optional>] message : string | null) =
+            match value with
+            | ValueSome _ -> Assert.Fail (message)
+            | ValueNone -> ()
+
+        static member WantOk (value, [<Optional>] message : string | null) =
+            match value with
+            | Ok ok -> ok
+            | Error error ->
+                match message with
+                | null -> Assert.Fail (string error)
+                | message -> Assert.Fail ($"'{message}': {error}")
+                Unchecked.defaultof<_>
+
+        static member IsOk (value, [<Optional>] message : string | null) = Assert.WantOk (value, message) |> ignore
+
+        static member WantError (value, [<Optional>] message : string | null) =
+            match value with
+            | Error error -> error
+            | Ok value ->
+                match message with
+                | null -> Assert.Fail (string value)
+                | message -> Assert.Fail ($"'{message}': {value}")
+                Unchecked.defaultof<_>
+
+        static member IsError (value, [<Optional>] message : string | null) = Assert.WantError (value, message) |> ignore
+
+        static member inline IsDefaultOf< ^T> (value : ^T, [<Optional>] message : string) =
+            Assert.AreEqual (box value, box Unchecked.defaultof< ^T>, message)
+
+        static member inline OkEquals< ^R, 'E> (expected : ^R, actual : Result< ^R, 'E >, [<Optional>] message : string | null) =
+            Assert.AreEqual (box expected, box (Assert.WantOk (actual, message)), message)
+
+        static member inline ErrorEquals<'R, ^E> (expected : ^E, actual : Result<'R, ^E>, [<Optional>] message : string | null) =
+            Assert.AreEqual (box expected, box (Assert.WantError (actual, message)), message)
+
+        static member FailWithData<'T> ([<Optional>] message : string | null) =
+            Assert.Fail (message)
+            Unchecked.defaultof<'T>