Refactored all async tests to task CE

Author: xperiandri

tests/FSharp.Data.GraphQL.IntegrationTests/LocalProviderTests.fs

@@ -1,8 +1,9 @@
 module FSharp.Data.GraphQL.IntegrationTests.LocalProviderTests
 
 open Xunit
-open Helpers
+open System.Threading.Tasks
 open FSharp.Data.GraphQL
+open Helpers
 
 let [<Literal>] ServerUrl = "http://localhost:8085"
 let [<Literal>] EmptyGuidAsString = "00000000-0000-0000-0000-000000000000"
@@ -66,16 +67,16 @@ let ``Should be able to execute a query using context, without sending input fie
     |> SimpleOperation.validateResult None
 
 [<Fact>]
-let ``Should be able to execute a query without sending input field asynchronously``() =
-    SimpleOperation.operation.AsyncRun()
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult None
+let ``Should be able to execute a query without sending input field asynchronously``() : Task = task {
+    let! result = SimpleOperation.operation.AsyncRun()
+    result |> SimpleOperation.validateResult None
+}
 
 [<Fact>]
-let ``Should be able to execute a query using context, without sending input field, asynchronously``() =
-    SimpleOperation.operation.AsyncRun(context)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult None
+let ``Should be able to execute a query using context, without sending input field, asynchronously``() : Task = task {
+    let! result = SimpleOperation.operation.AsyncRun(context)
+    result |> SimpleOperation.validateResult None
+}
 
 [<Fact>]
 let ``Should be able to execute a query sending an empty input field``() =
@@ -90,18 +91,18 @@ let ``Should be able to execute a query using context, sending an empty input fi
     |> SimpleOperation.validateResult (Some input)
 
 [<Fact>]
-let ``Should be able to execute a query without sending an empty input field asynchronously``() =
+let ``Should be able to execute a query without sending an empty input field asynchronously``() : Task = task {
     let input = Input()
-    SimpleOperation.operation.AsyncRun(input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
-let ``Should be able to execute a query using context, sending an empty input field, asynchronously``() =
+let ``Should be able to execute a query using context, sending an empty input field, asynchronously``() : Task = task {
     let input = Input()
-    SimpleOperation.operation.AsyncRun(context, input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(context, input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
 let ``Should be able to execute a query sending an input field with single field``() =
@@ -118,20 +119,20 @@ let ``Should be able to execute a query using context, sending an input field wi
     |> SimpleOperation.validateResult (Some input)
 
 [<Fact>]
-let ``Should be able to execute a query without sending an input field with single field asynchronously``() =
+let ``Should be able to execute a query without sending an input field with single field asynchronously``() : Task = task {
     let single = InputField("A", 2, System.Uri("http://localhost:1234"),  EmptyGuidAsString)
     let input = Input(single)
-    SimpleOperation.operation.AsyncRun(input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
-let ``Should be able to execute a query using context, sending an input field with single field, asynchronously``() =
+let ``Should be able to execute a query using context, sending an input field with single field, asynchronously``() : Task = task {
     let single = InputField("A", 2, System.Uri("http://localhost:1234"), EmptyGuidAsString)
     let input = Input(single)
-    SimpleOperation.operation.AsyncRun(context, input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(context, input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
 let ``Should be able to execute a query sending an input field with list field``() =
@@ -148,20 +149,20 @@ let ``Should be able to execute a query using context, sending an input field wi
     |> SimpleOperation.validateResult (Some input)
 
 [<Fact>]
-let ``Should be able to execute a query without sending an input field with list field asynchronously``() =
+let ``Should be able to execute a query without sending an input field with list field asynchronously``() : Task = task {
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"),  EmptyGuidAsString)|]
     let input = Input(list)
-    SimpleOperation.operation.AsyncRun(input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
-let ``Should be able to execute a query using context, sending an input field with list field, asynchronously``() =
+let ``Should be able to execute a query using context, sending an input field with list field, asynchronously``() : Task = task {
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(list)
-    SimpleOperation.operation.AsyncRun(context, input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(context, input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
 let ``Should be able to execute a query sending an input field with single and list fields``() =
@@ -180,22 +181,22 @@ let ``Should be able to execute a query using context, sending an input field wi
     |> SimpleOperation.validateResult (Some input)
 
 [<Fact>]
-let ``Should be able to execute a query without sending an input field with single and list fields asynchronously``() =
+let ``Should be able to execute a query without sending an input field with single and list fields asynchronously``() : Task = task {
     let single = InputField("A", 2, System.Uri("http://localhost:1234"), EmptyGuidAsString)
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(single, list)
-    SimpleOperation.operation.AsyncRun(input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 [<Fact>]
-let ``Should be able to execute a query using context, sending an input field with single and list fields, asynchronously``() =
+let ``Should be able to execute a query using context, sending an input field with single and list fields, asynchronously``() : Task = task {
     let single = InputField("A", 2, System.Uri("http://localhost:1234"), EmptyGuidAsString)
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(single, list)
-    SimpleOperation.operation.AsyncRun(context, input)
-    |> Async.RunSynchronously
-    |> SimpleOperation.validateResult (Some input)
+    let! result = SimpleOperation.operation.AsyncRun(context, input)
+    result |> SimpleOperation.validateResult (Some input)
+}
 
 module SingleRequiredUploadOperation =
     let operation =
@@ -223,11 +224,11 @@ let ``Should be able to execute a single required upload``() =
     |> SingleRequiredUploadOperation.validateResult file
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a single required upload asynchronously``() =
+let ``Should be able to execute a single required upload asynchronously``() : Task = task {
     let file = { Name = "file.txt"; ContentType = "text/plain"; Content = "Sample text file contents" }
-    SingleRequiredUploadOperation.operation.AsyncRun(file.MakeUpload())
-    |> Async.RunSynchronously
-    |> SingleRequiredUploadOperation.validateResult file
+    let! result = SingleRequiredUploadOperation.operation.AsyncRun(file.MakeUpload())
+    result |> SingleRequiredUploadOperation.validateResult file
+}
 
 module SingleOptionalUploadOperation =
     let operation =
@@ -257,22 +258,22 @@ let ``Should be able to execute a single optional upload by passing a file``() =
     |> SingleOptionalUploadOperation.validateResult (Some file)
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a single optional upload by passing a file, asynchronously``() =
+let ``Should be able to execute a single optional upload by passing a file, asynchronously``() : Task = task {
     let file = { Name = "file.txt"; ContentType = "text/plain"; Content = "Sample text file contents" }
-    SingleOptionalUploadOperation.operation.AsyncRun(file.MakeUpload())
-    |> Async.RunSynchronously
-    |> SingleOptionalUploadOperation.validateResult (Some file)
+    let! result = SingleOptionalUploadOperation.operation.AsyncRun(file.MakeUpload())
+    result |> SingleOptionalUploadOperation.validateResult (Some file)
+}
 
 [<Fact(Skip = "Temporary broken")>]
 let ``Should be able to execute a single optional upload by not passing a file``() =
     SingleOptionalUploadOperation.operation.Run()
     |> SingleOptionalUploadOperation.validateResult None
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a single optional upload by not passing a file asynchronously``() =
-    SingleOptionalUploadOperation.operation.AsyncRun()
-    |> Async.RunSynchronously
-    |> SingleOptionalUploadOperation.validateResult None
+let ``Should be able to execute a single optional upload by not passing a file asynchronously``() : Task = task {
+    let! result = SingleOptionalUploadOperation.operation.AsyncRun()
+    result |> SingleOptionalUploadOperation.validateResult None
+}
 
 module RequiredMultipleUploadOperation =
     let operation =
@@ -303,13 +304,13 @@ let ``Should be able to execute a multiple required upload``() =
     |> RequiredMultipleUploadOperation.validateResult files
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple required upload asynchronously``() =
+let ``Should be able to execute a multiple required upload asynchronously``() : Task = task {
     let files =
         [| { Name = "file1.txt"; ContentType = "text/plain"; Content = "Sample text file contents 1" }
            { Name = "file2.txt"; ContentType = "text/plain"; Content = "Sample text file contents 2" } |]
-    RequiredMultipleUploadOperation.operation.AsyncRun(files |> Array.map (fun f -> f.MakeUpload()))
-    |> Async.RunSynchronously
-    |> RequiredMultipleUploadOperation.validateResult files
+    let! result = RequiredMultipleUploadOperation.operation.AsyncRun(files |> Array.map (fun f -> f.MakeUpload()))
+    result |> RequiredMultipleUploadOperation.validateResult files
+}
 
 module OptionalMultipleUploadOperation =
     let operation =
@@ -340,24 +341,24 @@ let ``Should be able to execute a multiple upload``() =
     |> OptionalMultipleUploadOperation.validateResult (Some files)
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple upload asynchronously``() =
+let ``Should be able to execute a multiple upload asynchronously``() : Task = task {
     let files =
         [| { Name = "file1.txt"; ContentType = "text/plain"; Content = "Sample text file contents 1" }
            { Name = "file2.txt"; ContentType = "text/plain"; Content = "Sample text file contents 2" } |]
-    OptionalMultipleUploadOperation.operation.AsyncRun(files |> Array.map (fun f -> f.MakeUpload()))
-    |> Async.RunSynchronously
-    |> OptionalMultipleUploadOperation.validateResult (Some files)
+    let! result = OptionalMultipleUploadOperation.operation.AsyncRun(files |> Array.map (fun f -> f.MakeUpload()))
+    result |> OptionalMultipleUploadOperation.validateResult (Some files)
+}
 
 [<Fact(Skip = "Temporary broken")>]
 let ``Should be able to execute a multiple upload by sending no uploads``() =
     OptionalMultipleUploadOperation.operation.Run()
     |> OptionalMultipleUploadOperation.validateResult None
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple upload asynchronously by sending no uploads``() =
-    OptionalMultipleUploadOperation.operation.AsyncRun()
-    |> Async.RunSynchronously
-    |> OptionalMultipleUploadOperation.validateResult None
+let ``Should be able to execute a multiple upload asynchronously by sending no uploads``() : Task = task {
+    let! result = OptionalMultipleUploadOperation.operation.AsyncRun()
+    result |> OptionalMultipleUploadOperation.validateResult None
+}
 
 module OptionalMultipleOptionalUploadOperation =
     let operation =
@@ -388,24 +389,24 @@ let ``Should be able to execute a multiple optional upload``() =
     |> OptionalMultipleOptionalUploadOperation.validateResult (Some files)
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple optional upload asynchronously``() =
+let ``Should be able to execute a multiple optional upload asynchronously``() : Task = task {
     let files =
         [| Some { Name = "file1.txt"; ContentType = "text/plain"; Content = "Sample text file contents 1" }
            Some { Name = "file2.txt"; ContentType = "text/plain"; Content = "Sample text file contents 2" } |]
-    OptionalMultipleOptionalUploadOperation.operation.AsyncRun(files |> Array.map (Option.map (fun f -> f.MakeUpload())))
-    |> Async.RunSynchronously
-    |> OptionalMultipleOptionalUploadOperation.validateResult (Some files)
+    let! result = OptionalMultipleOptionalUploadOperation.operation.AsyncRun(files |> Array.map (Option.map (fun f -> f.MakeUpload())))
+    result |> (OptionalMultipleOptionalUploadOperation.validateResult (Some files))
+}
 
 [<Fact(Skip = "Temporary broken")>]
 let ``Should be able to execute a multiple optional upload by sending no uploads``() =
     OptionalMultipleOptionalUploadOperation.operation.Run()
     |> OptionalMultipleOptionalUploadOperation.validateResult None
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple optional upload asynchronously by sending no uploads``() =
-    OptionalMultipleOptionalUploadOperation.operation.AsyncRun()
-    |> Async.RunSynchronously
-    |> OptionalMultipleOptionalUploadOperation.validateResult None
+let ``Should be able to execute a multiple optional upload asynchronously by sending no uploads``() : Task = task {
+    let! result = OptionalMultipleOptionalUploadOperation.operation.AsyncRun()
+    result |> OptionalMultipleOptionalUploadOperation.validateResult None
+}
 
 [<Fact(Skip = "Temporary broken")>]
 let ``Should be able to execute a multiple optional upload by sending some uploads``() =
@@ -418,15 +419,15 @@ let ``Should be able to execute a multiple optional upload by sending some uploa
     |> OptionalMultipleOptionalUploadOperation.validateResult (Some files)
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to execute a multiple optional upload asynchronously by sending some uploads``() =
+let ``Should be able to execute a multiple optional upload asynchronously by sending some uploads``() : Task = task {
     let files =
         [| Some { Name = "file1.txt"; ContentType = "text/plain"; Content = "Sample text file contents 1" }
            None
            Some { Name = "file2.txt"; ContentType = "text/plain"; Content = "Sample text file contents 2" }
            None |]
-    OptionalMultipleOptionalUploadOperation.operation.AsyncRun(files |> Array.map (Option.map (fun f -> f.MakeUpload())))
-    |> Async.RunSynchronously
-    |> OptionalMultipleOptionalUploadOperation.validateResult (Some files)
+    let! result = OptionalMultipleOptionalUploadOperation.operation.AsyncRun(files |> Array.map (Option.map (fun f -> f.MakeUpload())))
+    result |> OptionalMultipleOptionalUploadOperation.validateResult (Some files)
+}
 
 module UploadRequestOperation =
     let operation =
@@ -466,7 +467,7 @@ module UploadRequestOperation =
         result.Data.Value.UploadRequest.NullableMultipleNullable |> Option.map (Array.map (Option.map ((fun x -> x.ToDictionary()) >> File.FromDictionary))) |> equals request.NullableMultipleNullable
 
 [<Fact(Skip = "Temporary broken")>]
-let ``Should be able to upload files inside another input type``() =
+let ``Should be able to upload files inside another input type``() : Task = task {
     let request =
         { Single = { Name = "single.txt"; ContentType = "text/plain"; Content = "Single file content" }
           Multiple =
@@ -481,5 +482,6 @@ let ``Should be able to upload files inside another input type``() =
                                        multiple = Array.map makeUpload request.Multiple,
                                        nullableMultiple = Array.map makeUpload request.NullableMultiple.Value,
                                        nullableMultipleNullable = Array.map (Option.map makeUpload) request.NullableMultipleNullable.Value)
-    UploadRequestOperation.operation.Run(input)
-    |> UploadRequestOperation.validateResult request
+    let! result = UploadRequestOperation.operation.AsyncRun(input)
+    result |> UploadRequestOperation.validateResult request
+}