Added Execution trait to all integration tests to mark async or sync

Author: xperiandri

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

@@ -56,131 +56,131 @@ module SimpleOperation =
                 let output = result.Data.Value.Echo.Value.Single.Value |> map (fun x -> x.Int, x.IntOption, x.String, x.StringOption, x.Uri, x.Guid)
                 input |> equals output))
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query without sending input field``() =
     SimpleOperation.operation.Run()
     |> SimpleOperation.validateResult None
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, without sending input field``() =
     SimpleOperation.operation.Run(context)
     |> SimpleOperation.validateResult None
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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>]
+[<Fact; Trait("Execution", "Async")>]
 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>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an empty input field``() =
     let input = Input()
     SimpleOperation.operation.Run(input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an empty input field``() =
     let input = Input()
     SimpleOperation.operation.Run(context, input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to execute a query without sending an empty input field asynchronously``() : Task = task {
     let input = Input()
     let! result = SimpleOperation.operation.AsyncRun(input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to execute a query using context, sending an empty input field, asynchronously``() : Task = task {
     let input = Input()
     let! result = SimpleOperation.operation.AsyncRun(context, input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with single field``() =
     let single = InputField("A", 2, System.Uri("http://localhost:1234"), EmptyGuidAsString)
     let input = Input(single)
     SimpleOperation.operation.Run(input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with single field``() =
     let single = InputField("A", 2, System.Uri("http://localhost:1234"),  EmptyGuidAsString)
     let input = Input(single)
     SimpleOperation.operation.Run(context, input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)
     let! result = SimpleOperation.operation.AsyncRun(input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)
     let! result = SimpleOperation.operation.AsyncRun(context, input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with list field``() =
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(list)
     SimpleOperation.operation.Run(input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with list field``() =
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(list)
     SimpleOperation.operation.Run(context, input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)
     let! result = SimpleOperation.operation.AsyncRun(input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)
     let! result = SimpleOperation.operation.AsyncRun(context, input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with single and list fields``() =
     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.Run(input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with single and list fields``() =
     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.Run(context, input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)|]
@@ -189,7 +189,7 @@ let ``Should be able to execute a query without sending an input field with sing
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)|]

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

@@ -56,131 +56,131 @@ module SimpleOperation =
                 let output = result.Data.Value.Echo.Value.Single.Value |> map (fun x -> x.Int, x.IntOption, x.String, x.StringOption, x.Uri, x.Guid)
                 input |> equals output))
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query without sending input field``() =
     SimpleOperation.operation.Run()
     |> SimpleOperation.validateResult None
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, without sending input field``() =
     SimpleOperation.operation.Run(context)
     |> SimpleOperation.validateResult None
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to execute a query without sending input field asynchronously``() =
     SimpleOperation.operation.AsyncRun()
     |> Async.RunSynchronously
     |> SimpleOperation.validateResult None
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an empty input field``() =
     let input = Input()
     SimpleOperation.operation.Run(Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an empty input field``() =
     let input = Input()
     SimpleOperation.operation.Run(context, Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to execute a query without sending an empty input field asynchronously``() : Task = task {
     let input = Input()
     let! result = SimpleOperation.operation.AsyncRun(Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to execute a query using context, sending an empty input field, asynchronously``() : Task = task {
     let input = Input()
     let! result = SimpleOperation.operation.AsyncRun(context, Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with single field``() =
     let single = InputField("A", 2, System.Uri("http://localhost:1234"), EmptyGuidAsString)
     let input = Input(Some single)
     SimpleOperation.operation.Run(Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with single field``() =
     let single = InputField("A", 2, System.Uri("http://localhost:1234"),  EmptyGuidAsString)
     let input = Input(Some single)
     SimpleOperation.operation.Run(context, Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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(Some single)
     let! result = SimpleOperation.operation.AsyncRun(Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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(Some single)
     let! result = SimpleOperation.operation.AsyncRun(context, Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with list field``() =
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(list = Some list)
     SimpleOperation.operation.Run(Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with list field``() =
     let list = [|InputField("A", 2, System.Uri("http://localhost:4321"), EmptyGuidAsString)|]
     let input = Input(list = Some list)
     SimpleOperation.operation.Run(context, Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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 = Some list)
     let! result = SimpleOperation.operation.AsyncRun(Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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 = Some list)
     let! result = SimpleOperation.operation.AsyncRun(context, Some input)
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query sending an input field with single and list fields``() =
     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(Some single, Some list)
     SimpleOperation.operation.Run(Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to execute a query using context, sending an input field with single and list fields``() =
     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(Some single, Some list)
     SimpleOperation.operation.Run(context, Some input)
     |> SimpleOperation.validateResult (Some input)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)|]
@@ -189,7 +189,7 @@ let ``Should be able to execute a query without sending an input field with sing
     result |> SimpleOperation.validateResult (Some input)
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 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)|]

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

@@ -86,20 +86,20 @@ hero (id: "1000") {
             Name = Some "Luke Skywalker";};}"""
         actual |> equals expected
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to start a simple query operation synchronously`` () =
     use context = getContext()
     SimpleOperation.operation.Run(context)
     |> SimpleOperation.validateResult
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to start a simple query operation asynchronously`` () : Task = task {
     use context = getContext()
     let! result = SimpleOperation.operation.AsyncRun(context)
     result |> SimpleOperation.validateResult
 }
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to use pattern matching methods on an union type`` () =
     use context = getContext()
     let result = SimpleOperation.operation.Run(context)
@@ -158,13 +158,13 @@ module MutationOperation =
         result.Data.Value.SetMoon.Value.Name |> equals (Some "Tatooine")
         result.Data.Value.SetMoon.Value.IsMoon |> equals (Some true)
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to run a mutation synchronously`` () =
     use context = getContext()
     MutationOperation.operation.Run(context)
     |> MutationOperation.validateResult
 
-[<Fact>]
+[<Fact; Trait("Execution", "Async")>]
 let ``Should be able to run a mutation asynchronously`` () : Task = task {
     use context = getContext()
     let! result = MutationOperation.operation.AsyncRun(context)
@@ -212,7 +212,7 @@ module FileOperation =
             Name = Some "Luke Skywalker";};}"""
         actual |> equals expected
 
-[<Fact>]
+[<Fact; Trait("Execution", "Sync")>]
 let ``Should be able to run a query from a query file`` () =
     use context = getContext()
     FileOperation.fileop.Run(context)