public async Task Test_Recieve_Multiple_Subscribers()
{
// Arrange
var tokenSource = new CancellationTokenSource();
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Create websocket GraphQL client
var wsClient = _factory.Server.CreateWebSocketClient();
wsClient.ConfigureRequest = request => request.Headers.Add("Sec-WebSocket-Protocol", "graphql-ws");
var wsUri = new UriBuilder(_factory.Server.BaseAddress)
{
Scheme = "wss",
Path = "graphql"
}.Uri;
var websocket = await wsClient.ConnectAsync(wsUri, tokenSource.Token);
var graphQLSubscriptionClient = new GraphQLSubscriptionClient(websocket, tokenSource.Token, new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());
await graphQLSubscriptionClient.Initilize();
// Act
// Registrer operations
var operationByUser = await graphQLSubscriptionClient.ExecuteOperation <MessageAddedByUserSubscription>(new GraphQLQueryArgument("fromId", "SAHB"));
List <GraphQLDataResult <MessageAddedByUserSubscription> > recievedDataByUser = new List <GraphQLDataResult <MessageAddedByUserSubscription> >();
operationByUser.DataRecieved += (sender, e) =>
{
recievedDataByUser.Add(e.ReceivedData);
};
var operation = await graphQLSubscriptionClient.ExecuteOperation <MessageAddedSubscription>();
List <GraphQLDataResult <MessageAddedSubscription> > recievedData = new List <GraphQLDataResult <MessageAddedSubscription> >();
operation.DataRecieved += (sender, e) =>
{
recievedData.Add(e.ReceivedData);
};
await Task.Delay(TimeSpan.FromSeconds(1));
// Send 2 message from 2 users only one should be retrieved in subscription
await graphQLClient.CreateMutation <SendMessageMutation>("http://localhost/graphql", arguments : new GraphQLQueryArgument("message", new MessageInputType
{
content = "Message 1",
fromId = "SAHB",
sentAt = DateTime.Now.AddDays(-1)
})).Execute();
await Task.Delay(TimeSpan.FromSeconds(1));
// Assert
Assert.Single(recievedDataByUser);
Assert.Single(recievedData);
}
public async Task ExampleGraphQL()
{
// TODO: Use dependency injection (services.AddGraphQLClient()) (IServiceCollection)
var client = GraphQLHttpClient.Default();
var response = await client.Query <Query>("https://mpjk0plp9.lp.gql.zone/graphql");
Assert.Equal("R2-D2", response.Hero.Name);
}
public async Task TestSimpleQuery()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.Execute <TestHelloQuery>(GraphQLOperationType.Query, "http://localhost/graphql");
// Assert
Assert.Equal("query", result.Hello);
}
public async Task Can_Get_Result_With_Enummember()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var query = await graphQLClient.CreateQuery <EmQuery>("http://localhost/graphql", arguments : new GraphQLQueryArgument("fromSrc", RdSrcWithEnumMember.correctValue)).Execute();
// Assert
Assert.Single(query.QryRdByEm);
}
public async Task TestSimpleMutation()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.CreateMutation <TestHelloMutation>("http://localhost/graphql").Execute();
// Assert
Assert.Equal("mutation", result.Hello);
}
public async Task Test_IntrospectionResult_Does_Not_Contain_Errors()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").ExecuteDetailed();
// Assert
Assert.False(result.ContainsErrors);
}
public async Task Can_Get_Result_Without_Inline()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var query = await graphQLClient.CreateQuery <EmQueryWUInline>("http://localhost/graphql", arguments : new GraphQLQueryArgument("fromSrc", RdSrc.XB)).Execute();
// Assert
Assert.Single(query.QryRdByEm);
}
public void Default_Creates_New_GraphQLClient()
{
// Arrange / Act
var actual = GraphQLHttpClient.Default();
// Assert
Assert.NotNull(actual);
Assert.NotNull(actual.FieldBuilder);
Assert.NotNull(actual.HttpExecutor);
Assert.NotNull(actual.QueryGenerator);
Assert.NotNull(actual.Deserialization);
Assert.NotNull(actual.FilterGenerator);
}
public async Task Validate_NonNullHello_Query_IsValid()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <TestNonNullQuery>(GraphQLOperationType.Query);
// Assert
Assert.Empty(validationOutput);
}
public async Task TestHelloQueryDirectiveNotInclude()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.Execute <TestHelloQueryDirective>(GraphQLOperationType.Query,
"http://localhost/graphql",
arguments : new GraphQLQueryDirectiveArgument("variableif", "include", false));
// Assert
Assert.Null(result.Hello);
}
public async Task Validate_Hello_Query_Argument_WrongType()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <TestWrongTypeArgument>(GraphQLOperationType.Query);
// Assert
Assert.Single(validationOutput);
Assert.Equal(ValidationType.Argument_Invalid_Type, validationOutput.First().ValidationType);
}
public void Default_WithClient_Creates_New_GraphQLClient()
{
// Arrange
var client = new HttpClient()
{
BaseAddress = new Uri("https://google.com/")
};
// Act
var actual = GraphQLHttpClient.Default(client);
// Assert
Assert.Equal(client, actual.HttpExecutor.Client);
Assert.Equal(client.BaseAddress.OriginalString, actual.HttpExecutor.Client.BaseAddress.OriginalString);
}
public async Task Validate_Query_IsValid()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <Issue91Query>(GraphQLOperationType.Query);
// Assert
Assert.Equal(2, validationOutput.Count());
Assert.All(validationOutput, e => Assert.Equal(ValidationType.Field_Should_Be_NonNull, e.ValidationType));
}
public async Task TestHello2()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.Execute <TestHelloQuery>(GraphQLOperationType.Query, "http://localhost/graphql", filter : e => new TestHelloQuery {
Hello1 = e.Hello2
});
// Assert
Assert.Equal("query", result.Hello2);
Assert.Null(result.Hello1);
}
public async Task Validate_Wrong_PossibleType()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <TestHelloInterfaceWithWrongInterface>(GraphQLOperationType.Query);
// Assert
Assert.Single(validationOutput);
Assert.Equal(ValidationType.PossibleType_Not_Found, validationOutput.First().ValidationType);
}
public async Task Validate_Introspection_IsValid()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <GraphQLIntrospectionQuery>(GraphQLOperationType.Query);
// Assert
// GraphQL has by an error set isDeprecated to a String! instead of a Boolean! and therefore this test should return one validationError
// This is fixed in https://github.com/graphql-dotnet/graphql-dotnet/commit/abf351892dda7bc8cf3dd83aba1ce63ae1ce11fd#diff-d9710dc6d5945261ad8c70084443f0c2
Assert.Single(validationOutput);
Assert.Equal("__schema.types.enumValues.isDeprecated", validationOutput.FirstOrDefault().Path);
Assert.Equal(ValidationType.Field_Invalid_Type, validationOutput.FirstOrDefault().ValidationType);
}
public async Task TestSimpleUnion()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.Execute <TestHelloUnion>(GraphQLOperationType.Query, "http://localhost/graphql");
// Assert
Assert.Equal(typeof(CatType), result.Cat.GetType());
Assert.Equal(typeof(DogType), result.Dog.GetType());
Assert.Equal("cat", ((CatType)result.Cat).Cat);
Assert.Equal("dog", ((DogType)result.Dog).Dog);
// Test number is different
Assert.True(((CatType)result.Cat).Number != ((DogType)result.Dog).Number);
}
public async Task TestBatchMutation()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var batch = graphQLClient.CreateBatch(GraphQLOperationType.Mutation, "http://localhost/graphql");
var query1 = batch.Query <TestHelloMutation>();
var query2 = batch.Query <TestHelloMutation>();
var result1 = await query1.Execute();
var result2 = await query2.Execute();
// Assert
Assert.Equal("mutation", result1.Hello);
Assert.Equal("mutation", result2.Hello);
}
public async Task Test_Complete()
{
// Arrange
var tokenSource = new CancellationTokenSource();
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Create websocket GraphQL client
var wsClient = _factory.Server.CreateWebSocketClient();
wsClient.ConfigureRequest = request => request.Headers.Add("Sec-WebSocket-Protocol", "graphql-ws");
var wsUri = new UriBuilder(_factory.Server.BaseAddress)
{
Scheme = "wss",
Path = "graphql"
}.Uri;
var websocket = await wsClient.ConnectAsync(wsUri, tokenSource.Token);
var graphQLSubscriptionClient = new GraphQLSubscriptionClient(websocket, tokenSource.Token, new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());
await graphQLSubscriptionClient.Initilize();
// Act
List <bool> completedTimes = new List <bool>();
// Registrer operations and stop it
var operation = await graphQLSubscriptionClient.ExecuteOperation <MessageAddedSubscription>();
operation.Completed += (sender, e) =>
{
completedTimes.Add(true);
};
await operation.Stop();
await Task.Delay(TimeSpan.FromSeconds(2));
// Assert
Assert.Single(completedTimes);
}
public void Client_Should_Throw_When_No_Matching_Argument_Found()
{
// Arrange
var client = GraphQLHttpClient.Default();
// Act / Assert
var exception = Assert.Throws <GraphQLArgumentVariableNotFoundException>(() =>
{
// Get the query
var query = client.CreateQuery <SampleQuery>("url", arguments:
new GraphQLQueryArgument("helloVariableName", "helloVariableValue"));
});
// Assert
// Should contain one element
Assert.Equal(1, exception.Arguments.Count());
// Argument should contain helloArgument and value
Assert.Equal("helloVariableName", exception.Arguments.First().VariableName);
Assert.Equal("helloVariableValue", exception.Arguments.First().ArgumentValue);
}
public async Task Validate_Hello_Query_IsDeprecated()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var introspectionQuery = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>(
"http://localhost/graphql",
arguments : new[]
{
new GraphQLQueryArgument("fieldsIncludeDeprecated", true),
new GraphQLQueryArgument("enumValuesIncludeDeprecated", true)
})
.Execute();
var validationOutput = introspectionQuery.ValidateGraphQLType <TestHelloQuery>(GraphQLOperationType.Query);
// Assert
Assert.Single(validationOutput);
Assert.Equal(ValidationType.Field_Deprecated, validationOutput.First().ValidationType);
}
public async Task TestBatchUnion()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var batch = graphQLClient.CreateBatch(GraphQLOperationType.Query, "http://localhost/graphql");
var query1 = batch.Query <TestHelloUnion>();
var query2 = batch.Query <TestHelloUnion>();
var result1 = await query1.Execute();
var result2 = await query2.Execute();
// Assert
Assert.Equal(typeof(CatType), result1.Cat.GetType());
Assert.Equal(typeof(DogType), result1.Dog.GetType());
Assert.Equal("cat", ((CatType)result1.Cat).Cat);
Assert.Equal("dog", ((DogType)result1.Dog).Dog);
Assert.Equal(typeof(CatType), result2.Cat.GetType());
Assert.Equal(typeof(DogType), result2.Dog.GetType());
Assert.Equal("cat", ((CatType)result2.Cat).Cat);
Assert.Equal("dog", ((DogType)result2.Dog).Dog);
// Test number is different
var allNumbers = new List <int>
{
((CatType)result1.Cat).Number,
((DogType)result1.Dog).Number,
((CatType)result2.Cat).Number,
((DogType)result2.Dog).Number
};
Assert.False(allNumbers.GroupBy(e => e).Where(e => e.Count() > 1).Any());
}
static async Task Main(string[] args)
{
using (IGraphQLSubscriptionWebSocketClient wssClient = GraphQLSubscriptionWebSocketClient.Default())
{
// Connect
var graphQLSubscriptionClient = await wssClient.Connect(new Uri("ws://localhost:60340/graphql"));
if (!graphQLSubscriptionClient.IsConnected)
{
Console.WriteLine("Could not connect!");
Console.ReadKey();
return;
}
// Initilize
await graphQLSubscriptionClient.Initilize();
if (!graphQLSubscriptionClient.IsInitilized)
{
Console.WriteLine("Could not initilize!");
Console.ReadKey();
return;
}
var operation = await graphQLSubscriptionClient.ExecuteOperation <MessageSubscription>();
operation.DataRecieved += (sender, e) =>
{
Console.WriteLine("Opration 1: " + e.ReceivedData.Data.MessageAdded.From.Id + ": " + e.ReceivedData.Data.MessageAdded.Content);
};
var operation2 = await graphQLSubscriptionClient.ExecuteOperation <MessageSubscription>();
operation2.DataRecieved += (sender, e) =>
{
Console.WriteLine("Operation 2: " + e.ReceivedData.Data.MessageAdded.From.Id + ": " + e.ReceivedData.Data.MessageAdded.Content);
};
var operation3 = await graphQLSubscriptionClient.ExecuteOperation <MessageSubscription>();
operation3.DataRecieved += (sender, e) =>
{
Console.WriteLine("Operation 3: " + e.ReceivedData.Data.MessageAdded.From.Id + ": " + e.ReceivedData.Data.MessageAdded.Content);
};
// Send message
var client = GraphQLHttpClient.Default();
await client.CreateMutation <SendMessageMutation>("http://localhost:60340/graphql", arguments : new GraphQLQueryArgument("message", new MessageInputType
{
content = "Message 1",
fromId = "SAHB",
sentAt = DateTime.Now.AddDays(-1)
})).Execute();
await operation.Stop();
Console.ReadKey();
await client.CreateMutation <SendMessageMutation>("http://localhost:60340/graphql", arguments : new GraphQLQueryArgument("message", new MessageInputType
{
content = "Message 2",
fromId = "SAHB"
})).Execute();
Console.ReadKey();
await wssClient.Disconnect();
Console.ReadKey();
}
}
static async Task Main(string[] args)
{
IGraphQLHttpClient client = GraphQLHttpClient.Default();
// Get response from url using the HeroQuery object
var response = await client.Query <HeroQuery>("https://mpjk0plp9.lp.gql.zone/graphql");
Console.WriteLine(response.Hero.Name);
// Get response from url using a generated object
var query = client.CreateQuery(builder =>
builder.Field("hero",
hero =>
hero
.Field("name")
.Field("friends",
friends =>
friends.Alias("MyFriends").Field("name"))),
"https://mpjk0plp9.lp.gql.zone/graphql");
var builderResponse = await query.Execute();
Console.WriteLine(builderResponse["hero"]["name"].Value);
foreach (var friend in builderResponse["hero"]["MyFriends"])
{
Console.WriteLine(friend["name"].Value);
}
// Get response from url using a generated object without alias
query = client.CreateQuery(builder =>
builder.Field("hero",
hero =>
hero
.Field("name")
.Field("friends",
friends =>
friends.Field("name"))),
"https://mpjk0plp9.lp.gql.zone/graphql");
builderResponse = await query.Execute();
Console.WriteLine(builderResponse["hero"]["name"].Value);
var character = await client.Query <CharacterQuery>("https://mpjk0plp9.lp.gql.zone/graphql", arguments : new GraphQLQueryArgument("characterID", "1000"));
if (character.Character is Human human)
{
Console.WriteLine("Human!: " + human.Height);
}
// Create batch
var batch = client.CreateBatch("https://mpjk0plp9.lp.gql.zone/graphql");
// Create two requests in the batch
var queryId1000 = batch.Query <CharacterQuery>(new GraphQLQueryArgument("characterID", "1000"));
var queryId1001 = batch.Query <CharacterQuery>(new GraphQLQueryArgument("characterID", "1001"));
// Execute the batch
var queryId1000Result = await queryId1000.Execute();
var queryId1001Result = await queryId1001.Execute();
// Get result
Console.WriteLine(queryId1000Result.Character.Name);
Console.WriteLine(queryId1001Result.Character.Name);
if (queryId1000Result.Character is Human human2)
{
Console.WriteLine("Human!: " + human2.Height);
}
else if (queryId1000Result.Character is Droid droid2)
{
Console.WriteLine("Droid!: " + droid2.PrimaryFunction);
}
// Create executor
IGraphQLHttpExecutor executor = new GraphQLHttpExecutor();
var result = await executor.ExecuteQuery(@"{""query"":""query{Hero:hero{Name:name Friends:friends{Name:name}}}""}",
"https://mpjk0plp9.lp.gql.zone/graphql", HttpMethod.Post);
IGraphQLDeserialization graphQLDeserialization = new GraphQLDeserilization();
var deserilizedResult = graphQLDeserialization.DeserializeResult <HeroQuery>(result.Response, null);
Console.WriteLine(deserilizedResult.Data.Hero.Name);
// Using dependency injection and console logging
var serviceCollection = new ServiceCollection();
serviceCollection
.AddLogging(logging => logging.AddConsole().SetMinimumLevel(LogLevel.Information))
.AddGraphQLHttpClient();
var serviceProvider = serviceCollection.BuildServiceProvider();
// Get client
client = serviceProvider.GetRequiredService <IGraphQLHttpClient>();
// Get response from url using the HeroQuery object
response = await client.Query <HeroQuery>("https://mpjk0plp9.lp.gql.zone/graphql");
Console.WriteLine(response.Hero.Name);
// Swapi
var swapiResponse = await client.Query <SwapiQuery>("https://swapi.apis.guru/");
foreach (var movie in swapiResponse.AllFilms.Films)
{
Console.WriteLine(movie.Title);
}
var filmResponse = await client.Query <FilmQuery>("https://swapi.apis.guru/",
arguments : new GraphQLQueryArgument("filmIdVariable", "6"));
Console.WriteLine(filmResponse.Film.Title);
Console.ReadKey();
}
