Tests

Author: bartelink

src/FSharp.AWS.DynamoDB/TableContext.fs

@@ -805,6 +805,7 @@ type TableContext<'TRecord> internal
     /// <param name="clientRequestToken">The <c>ClientRequestToken</c> to supply as an idempotency key (10 minute window).</param>
     member _.TransactWriteItems(items : seq<TransactWrite<'TRecord>>, ?clientRequestToken) : Async<unit> = async {
         let reqs = TransactWriteItemsRequest.toTransactItems tableName template items
+        if (Seq.isEmpty reqs) || reqs.Count > 25 then raise <| System.ArgumentOutOfRangeException(nameof items, "must be between 1 and 25 items.")
         let req = TransactWriteItemsRequest(ReturnConsumedCapacity = returnConsumedCapacity, TransactItems = reqs)
         clientRequestToken |> Option.iter (fun x -> req.ClientRequestToken <- x)
         let! ct = Async.CancellationToken

tests/FSharp.AWS.DynamoDB.Tests/MetricsCollectorTests.fs

@@ -47,6 +47,8 @@ type TestCollector() =
 
     member _.Metrics = metrics |> Seq.toList
 
+    member _.Clear() = metrics.Clear()
+
 let (|TotalCu|) : ConsumedCapacity list -> float = Seq.sumBy (fun c -> c.CapacityUnits)
 
 /// Tests without common setup
@@ -79,6 +81,42 @@ type Tests(fixture : TableFixture) =
                     cu > 0
                 | _ -> false @>
 
+    let compile = rawTable.Template.PrecomputeConditionalExpr
+
+    let [<Fact>] ``Collect Metrics on Transactional PutItem`` () = async {
+        let item = mkItem (guid()) (guid()) 0
+        let _ = sut.PutItem item
+        let simpleCu = trap <@ match collector.Metrics with [{ ConsumedCapacity = TotalCu cu }] -> cu | x -> failwithf "Unexpected %A" x @>
+        collector.Clear()
+
+        let item = mkItem (guid()) (guid()) 0
+        let requests = [TransactWrite.Put (item, Some (compile <@ fun t -> NOT_EXISTS t.RangeKey @>)) ]
+
+        do! sut.TransactWriteItems requests
+
+        test <@ match collector.Metrics with
+                | [{ ItemCount = 1; Operation = TransactWriteItems; TableName = ExpectedTableName; ConsumedCapacity = TotalCu cu }] ->
+                            cu >= simpleCu * 2. // doing it transactionally costs at least double
+                | _ -> false @>
+
+        let! itemFound = sut.ContainsKeyAsync(sut.Template.ExtractKey item)
+        test <@ itemFound @> }
+
+    let [<Fact>] ``No Metrics on Canceled PutItem`` () = async {
+        let collector = TestCollector()
+        let sut = rawTable.WithMetricsCollector(collector.Collect)
+
+        let item = mkItem (guid()) (guid()) 0
+
+        // The check will fail, which triggers a throw from the underlying AWS SDK; there's no way to extract the consumption info in that case
+        let requests = [TransactWrite.Put (item, Some (compile <@ fun t -> EXISTS t.RangeKey @>)) ]
+
+        let mutable failed = false
+        try do! sut.TransactWriteItems requests
+        with TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed -> failed <- true
+        true =! failed
+        [] =! collector.Metrics }
+
     interface IClassFixture<TableFixture>
 
 /// Tests that look up a specific item. Each test run gets a fresh individual item
@@ -90,7 +128,6 @@ type ItemTests(fixture : TableFixture) =
     let item = mkItem (guid()) (guid()) 0
     do  rawTable.PutItem item |> ignore
 
-
     let collector = TestCollector()
     let sut = rawTable.WithMetricsCollector(collector.Collect)
 

tests/FSharp.AWS.DynamoDB.Tests/SimpleTableOperationTests.fs

@@ -2,6 +2,7 @@
 
 open System
 
+open FSharp.AWS.DynamoDB.Tests
 open Swensen.Unquote
 open Xunit
 
@@ -125,22 +126,102 @@ type ``Simple Table Operation Tests`` (fixture : TableFixture) =
         test <@ None = deletedItem @>
         test <@ not (table.ContainsKey key) @>
 
+    interface IClassFixture<TableFixture>
+
+type TransactWriteItems(fixture : TableFixture) =
+
+    let rand = let r = Random() in fun () -> int64 <| r.Next()
+    let mkItem() =
+        {
+            HashKey = guid() ; RangeKey = guid() ;
+            Value = rand() ; Tuple = rand(), rand() ;
+            Map = seq { for _ in 0L .. rand() % 5L -> "K" + guid(), rand() } |> Map.ofSeq
+            Unions = [Choice1Of3 (guid()) ; Choice2Of3(rand()) ; Choice3Of3(Guid.NewGuid().ToByteArray())]
+        }
+
+    let table = fixture.CreateEmpty<SimpleRecord>()
+    let compile = table.Template.PrecomputeConditionalExpr
+    let compileUpdate (e : Quotations.Expr<SimpleRecord -> SimpleRecord>) = table.Template.PrecomputeUpdateExpr e
+    let doesntExistCondition = compile <@ fun t -> NOT_EXISTS t.Value @>
+    let existsCondition = compile <@ fun t -> EXISTS t.Value @>
+
+    let [<Fact>] ``Minimal happy path`` () = async {
+        let item = mkItem ()
+
+        let requests = [TransactWrite.Put (item, Some doesntExistCondition) ]
+
+        do! table.TransactWriteItems requests
+
+        let! itemFound = table.ContainsKeyAsync (table.Template.ExtractKey item)
+        true =! itemFound }
+
+    let [<Fact>] ``Minimal Canceled path`` () = async {
+        let item = mkItem ()
+
+        let requests = [TransactWrite.Put (item, Some existsCondition) ]
+
+        let mutable failed = false
+        try do! table.TransactWriteItems requests
+        with TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed -> failed <- true
+
+        true =! failed
+
+        let! itemFound = table.ContainsKeyAsync (table.Template.ExtractKey item)
+        false =! itemFound }
+
     let [<Theory; InlineData true; InlineData false>]
         ``Condition Check outcome should affect sibling TransactWrite`` shouldFail = async {
         let item, item2 = mkItem (), mkItem ()
-        let key = table.PutItem item
+        let! key = table.PutItemAsync item
 
         let requests = [
-            if shouldFail then  TransactWrite.Check (key, table.Template.PrecomputeConditionalExpr <@ fun t -> NOT_EXISTS t.Value @>)
-            else                TransactWrite.Check (key, table.Template.PrecomputeConditionalExpr <@ fun t -> EXISTS t.Value @>)
+            if shouldFail then  TransactWrite.Check (key, doesntExistCondition)
+            else                TransactWrite.Check (key, existsCondition)
                                 TransactWrite.Put   (item2, None) ]
         let mutable failed = false
         try do! table.TransactWriteItems requests
         with TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed -> failed <- true
 
-        let failed = failed
-        test <@ failed = shouldFail @>
-        let item2Found = table.ContainsKey (table.Template.ExtractKey item2)
-        test <@ not shouldFail = item2Found @> }
+        failed =! shouldFail
+
+        let! item2Found = table.ContainsKeyAsync (table.Template.ExtractKey item2)
+        failed =! not item2Found }
+
+    let [<Theory; InlineData true; InlineData false>]
+        ``All paths`` shouldFail = async {
+        let item, item2, item3, item4, item5, item6, item7 = mkItem (), mkItem (), mkItem (), mkItem (), mkItem (), mkItem (), mkItem ()
+        let! key = table.PutItemAsync item
+
+        let requests = [ TransactWrite.Update (key, Some existsCondition, compileUpdate <@ fun t -> { t with Value = 42 } @>)
+                         TransactWrite.Put    (item2, None)
+                         TransactWrite.Put    (item3, Some doesntExistCondition)
+                         TransactWrite.Delete (table.Template.ExtractKey item4, Some doesntExistCondition)
+                         TransactWrite.Delete (table.Template.ExtractKey item5, None)
+                         TransactWrite.Check  (table.Template.ExtractKey item6, if shouldFail then existsCondition else doesntExistCondition)
+                         TransactWrite.Update (TableKey.Combined(item7.HashKey, item7.RangeKey), None, compileUpdate <@ fun t -> { t with Tuple = (42, 42)} @>) ]
+        let mutable failed = false
+        try do! table.TransactWriteItems requests
+        with TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed -> failed <- true
+        failed =! shouldFail
+
+        let! maybeItem = table.TryGetItemAsync key
+        test <@ shouldFail <> (maybeItem |> Option.contains { item with Value = 42 }) @>
+
+        let! maybeItem2 = table.TryGetItemAsync(table.Template.ExtractKey item2)
+        test <@ shouldFail <> (maybeItem2 |> Option.contains item2) @>
+
+        let! maybeItem3 = table.TryGetItemAsync(table.Template.ExtractKey item3)
+        test <@ shouldFail <> (maybeItem3 |> Option.contains item3) @>
+
+        let! maybeItem7 = table.TryGetItemAsync(table.Template.ExtractKey item7)
+        test <@ shouldFail <> (maybeItem7 |> Option.map (fun x -> x.Tuple) |> Option.contains (42, 42)) @> }
+
+    let [<Fact>] ``Empty is rejected`` () = async {
+
+        let! e = Async.Catch (table.TransactWriteItems [])
+
+        test <@ match e with
+                | Choice1Of2 () -> false
+                | Choice2Of2 e -> e :? ArgumentOutOfRangeException @> }
 
     interface IClassFixture<TableFixture>