public virtual void Execute_Selection_Object_Paging_Edges()
{
// arrange
IServiceCollection services;
Func <IResolverContext, IEnumerable <Foo> > resolver;
(services, resolver) = _provider.CreateResolver(SAMPLE);
Connection <Foo> resultCtx = null;
ISchema schema = SchemaBuilder.New()
.AddServices(services.BuildServiceProvider())
.AddQueryType <Query>(
d => d.Field(t => t.Foos)
.Resolver(resolver)
.Use(next => async ctx =>
{
await next(ctx).ConfigureAwait(false);
resultCtx = ctx.Result as Connection <Foo>;
})
.UsePaging <ObjectType <Foo> >()
.UseFiltering()
.UseSorting()
.UseSelection())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos { edges { node { bar }} } }");
// assert
Assert.NotNull(resultCtx);
Assert.Collection(resultCtx.Edges.ToArray(),
x =>
{
Assert.Equal("aa", x.Node.Bar);
Assert.Equal(0, x.Node.Baz);
Assert.Null(x.Node.Nested);
Assert.Null(x.Node.ObjectArray);
},
x =>
{
Assert.Equal("bb", x.Node.Bar);
Assert.Equal(0, x.Node.Baz);
Assert.Null(x.Node.Nested);
Assert.Null(x.Node.ObjectArray);
});
}
public Task Subscribe_With_ObjectValue()
{
return(TestHelper.TryTest(async() =>
{
// arrange
var services = new ServiceCollection();
services.AddRedisSubscriptionProvider(_connection);
IServiceProvider serviceProvider = services.BuildServiceProvider();
var cts = new CancellationTokenSource(30000);
string name = "field_" + Guid.NewGuid().ToString("N");
IQueryExecutor executor = SchemaBuilder.New()
.AddServices(serviceProvider)
.AddQueryType(d => d
.Name("foo")
.Field("a")
.Resolver("b"))
.AddSubscriptionType(d => d.Name("bar")
.Field(name)
.Argument("a", a => a.Type <FooType>())
.Resolver("baz"))
.Create()
.MakeExecutable();
var eventDescription = new EventDescription(name,
new ArgumentNode("a",
new ObjectValueNode(
new ObjectFieldNode("def", "xyz"))));
var outgoing = new EventMessage(eventDescription, "bar");
IExecutionResult result = executor.Execute(
"subscription { " + name + "(a: { def: \"xyz\" }) }");
// act
await _sender.SendAsync(outgoing);
// assert
var stream = (IResponseStream)result;
IReadOnlyQueryResult message = null;
await foreach (IReadOnlyQueryResult item in stream.WithCancellation(cts.Token))
{
message = item;
break;
}
Assert.Equal("baz", message.Data.First().Value);
}));
}
public void ExecutionDepthShouldNotLeadToEmptyObects()
{
// arrange
var query = @"
query ExecutionDepthShouldNotLeadToEmptyObects {
hero(episode: NEWHOPE) {
__typename
id
name
... on Human {
__typename
homePlanet
}
... on Droid {
__typename
primaryFunction
}
friends {
__typename
... on Human {
__typename
homePlanet
friends {
__typename
}
}
... on Droid {
__typename
primaryFunction
friends {
__typename
}
}
}
}
}";
IQueryExecutor executor = CreateSchema().MakeExecutable(
new QueryExecutionOptions {
MaxExecutionDepth = 3
});
// act
IExecutionResult result = executor.Execute(query);
// assert
result.MatchSnapshot();
}
public Room Create(string name)
{
var query = new FindRoomByNameQuery(name);
var roomNameIsAlreadyTaken = _queryExecute.Execute(query).Any();
if (roomNameIsAlreadyTaken)
{
throw new RoomNameIsAlreadyTakenException(name);
}
var newRoom = Room.CreateRoom(name, _clock.UtcNow);
_roomRepository.Add(newRoom);
return(newRoom);
}
public void Execute_Filter_Nullable_Equals_Null()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <Query>(d => d.Field(t => t.Foos).UseFiltering())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos(where: { qux: null }) { bar qux } }");
// assert
result.MatchSnapshot();
}
public void Execute_Filter_Is_Null()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos { bar } }");
// assert
result.MatchSnapshot();
}
/// <summary>
/// If a page isnt found, check to see if we have a redirection rule
/// in place for the url.
/// </summary>
private ActionResult GetRewriteResult(string path)
{
var query = new GetRewriteRuleByPathQuery()
{
Path = path
};
var rewriteRule = _queryExecutor.Execute(query);
if (rewriteRule != null)
{
string writeTo = rewriteRule.WriteTo;
return(new RedirectResult(rewriteRule.WriteTo, true));
}
return(null);
}
public void Infer_Filter_From_Field()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <Query>(d => d.Field(t => t.Foos).UseFiltering())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos(where: { bar_starts_with: \"a\" }) { bar } }");
// assert
result.MatchSnapshot();
}
public void Execute_Filter_Comparable_In()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <Query>(d => d.Field(t => t.Foos).UseFiltering())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos(where: { baz_in: [ 1 0 ] }) { bar } }");
// assert
result.MatchSnapshot();
}
public async Task <GetAllAssignmentsResponse> Handle(GetAllAssignmentsRequest request, CancellationToken cancellationToken)
{
var query = new GetAssignmentsQuery()
{
CustomerId = request.customerId,
CompanyId = request.AuthenticatorCompanyId
};
var assignments = await queryExecutor.Execute(query);
var mappedAssignments = mapper.Map <List <AssignmentDto> >(assignments);
return(new GetAllAssignmentsResponse()
{
Data = mappedAssignments
});
}
public void Execute_Filter()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos(where: { bar_starts_with: \"a\" }) { bar } }");
// assert
result.MatchSnapshot();
}
public static async Task <Member> Create(IQueryExecutor executor, OrganisationMemberDto data)
{
//does data.Email exists? no duplicates allowed
var value = await executor.Execute(new GetOrganisationMemberQuery(data.OrgId, data.Email));
if (value != null)
{
throw new ThisAppException(StatusCodes.Status409Conflict, Messages.Err409ObjectExists("Organisation Member"));
}
value = new Member(data);
await executor.Add <Member>(value);
await executor.Save();
return(value);
}
public void Execute_Selection_MultipleScalar()
{
// arrange
IServiceCollection services;
Func <IResolverContext, IEnumerable <Foo> > resolver;
(services, resolver) = _provider.CreateResolver(
Foo.Create("aa", 1, false),
Foo.Create("bb", 2, false));
IQueryable <Foo> resultCtx = null;
ISchema schema = SchemaBuilder.New()
.AddServices(services.BuildServiceProvider())
.AddQueryType <Query>(d =>
d.Field(t => t.Foos)
.Resolver(resolver)
.Use(next => async ctx =>
{
await next(ctx).ConfigureAwait(false);
resultCtx = ctx.Result as IQueryable <Foo>;
}))
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
executor.Execute(
"{ foos { bar baz } }");
// assert
Assert.NotNull(resultCtx);
Assert.Collection(resultCtx.ToArray(),
x =>
{
Assert.Equal("aa", x.Bar);
Assert.Equal(1, x.Baz);
Assert.Null(x.Nested);
Assert.Null(x.NestedCollection);
},
x =>
{
Assert.Equal("bb", x.Bar);
Assert.Equal(2, x.Baz);
Assert.Null(x.Nested);
Assert.Null(x.NestedCollection);
});
}
public void Execute_Filter_Equals_Or()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <Query>(d => d.Field(t => t.Foos).UseFiltering())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
"{ foos(where: { OR: [ { bar: \"aa\" } { bar: \"ba\" } ] })" +
" { bar } }");
// assert
result.MatchSnapshot();
}
public QueryResult Execute(
long userId,
[NotNull] ReportQuery reportQuery,
IEnumerable <KeyValuePair <string, string> > parameters)
{
if (reportQuery == null)
{
throw new ArgumentNullException(nameof(reportQuery));
}
if (string.IsNullOrEmpty(reportQuery.Text))
{
throw new Exception($"Empry report query. Query key='{reportQuery.Key}'");
}
return(_queryExecutor.Execute(reportQuery.Text, userId, parameters.ToArray()));
}
public User Create(string email, string plainTextPassword)
{
var query = new FindUserByEmailQuery(email);
var existingUser = _queryExecutor.Execute(query);
if (existingUser.Count > 0)
{
throw new EmailAddressAlreadyTakenException();
}
var hashedPassword = _passwordHashingService.SaltAndHash(plainTextPassword);
var user = User.Register(email, hashedPassword, _clock.UtcNow);
_userRepository.Add(user);
return(user);
}
protected void SearchButton_OnClick(object sender, EventArgs e)
{
var shipDtos = _queryExecutor.Execute <GetShipsByNameQuery, ShipDto>(
new GetShipsByNameQuery {
ShipName = SearchShipNameTextBox.Text
}
)
.ToList();
NumberOfShipQueriedLabel.Text = $"{shipDtos.Count}";
SearchedShipsListBox.Items.Clear();
foreach (var shipDto in shipDtos)
{
SearchedShipsListBox.Items.Add($"Id: {shipDto.Id}, ship name: {shipDto.Name}");
}
}
/// <summary>
/// Gets the JSON object from given resource class.
/// </summary>
/// <param name="resourceClassName">Name of the resource class.</param>
/// <param name="languageName">Name of the language.</param>
/// <param name="fallbackCollection">List of fallback languages collection.</param>
/// <param name="camelCase">if set to <c>true</c> JSON properties will be in camelCase; otherwise PascalCase is used.</param>
/// <returns>JSON object that represents resource</returns>
public JObject GetJson(
string resourceClassName,
string languageName,
FallbackLanguagesCollection fallbackCollection,
bool camelCase = false)
{
var resources = _queryExecutor.Execute(new GetAllResources.Query());
var filteredResources = resources
.Where(r => r.ResourceKey.StartsWith(resourceClassName, StringComparison.InvariantCultureIgnoreCase))
.ToList();
return(Convert(
filteredResources,
languageName,
fallbackCollection,
camelCase));
}
public async Task <GetAllEmployeesResponse> Handle(GetAllEmployeesRequest request, CancellationToken cancellationToken)
{
var query = new GetEmployeesQuery()
{
Name = request.Name,
Surname = request.Surname,
CompanyId = request.AuthenticatorCompanyId
};
var employes = await queryExecutor.Execute(query);
var mappedEmployes = mapper.Map <List <EmployeeDto> >(employes);
return(new GetAllEmployeesResponse()
{
Data = mappedEmployes
});
}
public async Task <AddBoardResponse> Handle(AddBoardRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new AddBoardResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetEmployeeQuery()
{
Id = request.EmployeeId
};
var employee = await queryExecutor.Execute(query);
if (employee == null)
{
return(new AddBoardResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
if (employee.Board != null)
{
return(new AddBoardResponse()
{
Error = new ErrorModel(ErrorType.UnsupportedMethod)
});
}
var board = mapper.Map <Board>(request);
var command = new AddBoardCommand()
{
Parameter = board
};
var boardFromDb = await commandExecutor.Execute(command);
return(new AddBoardResponse()
{
Data = mapper.Map <BoardDto>(boardFromDb)
});
}
public void ResolverResultIsObject()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.Create();
IQueryExecutor executor = schema.MakeExecutable();
// act
IExecutionResult result = executor.Execute(
QueryRequestBuilder.New()
.SetQuery("{ foo { bar { baz }}}")
.Create());
// assert
result.MatchSnapshot();
}
/// <summary>
/// Creates new translation class from single found text.
/// </summary>
/// <param name="translation">Text of the resource translation.</param>
/// <returns>Discovered translation (as list for easier other API support)</returns>
public List <DiscoveredTranslation> FromSingle(string translation)
{
var defaultCulture = _executor.Execute(new DetermineDefaultCulture.Query());
var result = new List <DiscoveredTranslation>
{
// invariant translation
new DiscoveredTranslation(translation, CultureInfo.InvariantCulture.Name)
};
// register additional culture if default is not set to invariant
if (defaultCulture != string.Empty)
{
result.Add(new DiscoveredTranslation(translation, defaultCulture));
}
return(result);
}
public QueryResult Execute(long userId, ReportQueryLink reportQuery, IEnumerable <KeyValuePair <string, string> > parameters)
{
List <KeyValuePair <string, string> > reportQueryParameters = null;
// ReSharper disable once InvertIf
if ((parameters != null) && (reportQuery.Parameters != null))
{
reportQueryParameters = new List <KeyValuePair <string, string> >(parameters);
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var queryParameter in reportQuery.Parameters)
{
reportQueryParameters.Add(new KeyValuePair <string, string>(queryParameter.Key, queryParameter.Value));
}
}
return(_queryExecutor.Execute(reportQuery.QueryId, userId, reportQueryParameters?.ToArray()));
}
public static IExecutionResult Execute(
this IQueryExecutor executor,
string query)
{
if (executor == null)
{
throw new ArgumentNullException(nameof(executor));
}
if (string.IsNullOrEmpty(query))
{
throw new ArgumentException(
CoreResources.QueryExecutorExtensions_QueryIsNullOrEmpty,
nameof(query));
}
return(executor.Execute(new QueryRequest(query)));
}
/// <inheritdoc/>
public bool Process(string name,
IDictionary <string, string> data, out string result)
{
IQuery query_to_execute = resolver_.GetQuery(name);
IQueryExecutor executor = resolver_.GetQueryExecutor(query_to_execute);
if (!(executor is NoOpQueryExecutor))
{
try {
result = executor.Execute(query_to_execute, data);
} catch (KeyNotFoundException key_not_found_exception) {
result = key_not_found_exception.Message;
}
return(true);
}
result = string.Format(Resources.QueryProcessor_ProcessorNotFound, name);
return(false);
}
internal static async Task <Badge> Create(IQueryExecutor executor, long appId, long stageId, string badgeUrl)
{
//validation - confirm app does not already exists
var existingValue = await executor.Execute(new GetBadgeQuery(appId, stageId));
if (existingValue != null)
{
throw new ThisAppException(StatusCodes.Status409Conflict, Messages.Err409ObjectExists("Badge"));
}
//create new record
var value = new Badge(appId, stageId, badgeUrl);
await executor.Add <Badge>(value);
await executor.Save();
//return record
return(value);
}
public void EnumValueIsCoercedToListValue()
{
// arrange
var query = @"
{
heroes(episodes: EMPIRE) {
name
}
}";
IQueryExecutor executor = CreateSchema().MakeExecutable();
// act
IExecutionResult result = executor.Execute(query);
// assert
result.MatchSnapshot();
}
public void Skip_With_Literal(string ifValue)
{
// arrange
var query = $@"
{{
human(id: ""1000"") {{
name @skip(if: {ifValue})
height
}}
}}";
IQueryExecutor executor = CreateSchema().MakeExecutable();
// act
IExecutionResult result = executor.Execute(query);
// assert
result.MatchSnapshot(new SnapshotNameExtension(ifValue));
}
public void GraphQLOrgFieldArgumentExample2()
{
// arrange
var query = @"
{
human(id: ""1000"") {
name
height(unit: FOOT)
}
}";
IQueryExecutor executor = CreateSchema().MakeExecutable();
// act
IExecutionResult result = executor.Execute(query);
// assert
result.MatchSnapshot();
}
internal static async Task <Organisation> Create(IQueryExecutor executor, string name, string masterEmail)
{
//validation
var existingValue = await executor.Execute(new GetOrganisationQuery(name, masterEmail));
if (existingValue != null)
{
throw new ThisAppException(StatusCodes.Status409Conflict, Messages.Err409ObjectExists("Organisation"));
}
//create new record
var value = new Organisation(name, masterEmail);
await executor.Add <Organisation>(value);
await executor.Save();
//return record
return(value);
}
internal IEnumerable<LucObject> Execute(bool allVersions, IQueryExecutor executor)
{
var result = executor.Execute(this, allVersions);
TotalCount = executor.TotalCount;
return result;
}
