public void UnsupportedDirective()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
name @foo(bar: true)
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified directive `foo` " +
"is not supported by the current schema.",
t.Message));
}
public void RequiredFieldIsNull()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
findDog2(complex: { name: null })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"`name` is a required field and cannot be null.",
t.Message));
}
public void NameFieldIsAmbiguous()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
findDog(complex: { name: ""A"", name: ""B"" })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"Field `name` is ambiguous.",
t.Message));
}
public void InvalidInputObjectFieldsExist()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
findDog(complex: { favoriteCookieFlavor: ""Bacon"" })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified input object field " +
"`favoriteCookieFlavor` does not exist.",
t.Message));
}
public void FragmentDoesNotMatchType()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...fragmentDoesNotMatchType
}
}
fragment fragmentDoesNotMatchType on Human {
name
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The parent type does not match the type condition on " +
"the fragment `fragmentDoesNotMatchType`.",
t.Message));
}
public OrganizationController(
OrganizationService organizationService,
IOrganizationRepository organizationRepository,
ICacheClient cacheClient,
IEventRepository eventRepository,
IUserRepository userRepository,
IProjectRepository projectRepository,
BillingManager billingManager,
IMailer mailer,
IMessagePublisher messagePublisher,
IMapper mapper,
IQueryValidator validator,
AppOptions options,
ILoggerFactory loggerFactory,
BillingPlans plans) : base(organizationRepository, mapper, validator, loggerFactory)
{
_organizationService = organizationService;
_cacheClient = cacheClient;
_eventRepository = eventRepository;
_userRepository = userRepository;
_projectRepository = projectRepository;
_billingManager = billingManager;
_mailer = mailer;
_messagePublisher = messagePublisher;
_options = options;
_plans = plans;
}
public void StringIntoInt()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
arguments {
...stringIntoInt
}
}
fragment stringIntoInt on Arguments {
intArgField(intArg: ""123"")
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified argument value does not match the " +
"argument type.\nArgument: `intArg`\nValue: `123`",
t.Message));
}
public void QueryWithTypeSystemDefinitions()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query getDogName {
dog {
name
color
}
}
extend type Dog {
color: String
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"A document containing TypeSystemDefinition " +
"is invalid for execution.", t.Message),
t => Assert.Equal(
"The field `color` does not exist " +
"on the type `Dog`.", t.Message));
}
public OrganizationController(
IOrganizationRepository organizationRepository,
ICacheClient cacheClient,
IEventRepository eventRepository,
IUserRepository userRepository,
IProjectRepository projectRepository,
IQueue <WorkItemData> workItemQueue,
BillingManager billingManager,
IMailer mailer,
IMessagePublisher messagePublisher,
IMapper mapper,
IQueryValidator validator,
IOptions <AppOptions> options,
IOptions <StripeOptions> stripeOptions,
ILoggerFactory loggerFactory,
BillingPlans plans) : base(organizationRepository, mapper, validator, loggerFactory)
{
_cacheClient = cacheClient;
_eventRepository = eventRepository;
_userRepository = userRepository;
_projectRepository = projectRepository;
_workItemQueue = workItemQueue;
_billingManager = billingManager;
_mailer = mailer;
_messagePublisher = messagePublisher;
_options = options;
_stripeOptions = stripeOptions;
_plans = plans;
}
public void MissingRequiredArgNonNullBooleanArg()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment missingRequiredArg on Arguments {
nonNullBooleanArgField(nonNullBooleanArg: null)
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"The argument `nonNullBooleanArg` is required " +
"and does not allow null values.", t.Message),
t => Assert.Equal(
"The specified fragment `missingRequiredArg` " +
"is not used within the current document.",
t.Message));
}
public void DisallowedSecondRootField()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
subscription sub {
newMessage {
body
sender
}
disallowedSecondRootField
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"Subscription operation `sub` must " +
"have exactly one root field.", t.Message),
t => Assert.Equal(
"The field `disallowedSecondRootField` does not exist " +
"on the type `Subscription`.", t.Message));
}
public void DuplicateArgument()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment goodNonNullArg on Arguments {
nonNullBooleanArgField(
nonNullBooleanArg: true, nonNullBooleanArg: true)
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"Arguments are not unique.", t.Message),
t => Assert.Equal(
"The specified fragment `goodNonNullArg` " +
"is not used within the current document.",
t.Message));
}
public void OperationWithTwoVariablesThatHaveTheSameName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query houseTrainedQuery(
$atOtherHomes: Boolean, $atOtherHomes: Boolean) {
dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"A document containing operations that " +
"define more than one variable with the same " +
"name is invalid for execution.", t.Message),
t => Assert.Equal(
"The field `isHousetrained` does not exist " +
"on the type `Dog`.", t.Message));
}
public void TwoQueryOperationsWithTheSameName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query getName {
dog {
name
}
}
query getName {
dog {
owner {
name
}
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"The operation name `getName` is not unique.",
t.Message));
}
public void VariableNotUsedWithinFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query variableNotUsedWithinFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedWithoutVariableFragment
}
}
fragment isHousetrainedWithoutVariableFragment on Dog {
barkVolume
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The following variables were not used: " +
"atOtherHomes.", t.Message));
}
public void ConflictingBecauseAlias()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment conflictingBecauseAlias on Dog {
name: nickname
name
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The query has non-mergable fields.",
t.Message),
t => Assert.Equal(
"The specified fragment `conflictingBecauseAlias` " +
"is not used within the current document.",
t.Message));
}
public void InlineFragOnScalar()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
... inlineFragOnScalar
}
}
fragment inlineFragOnScalar on Dog {
... on Boolean {
somethingElse
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"Fragments can only be declared on unions, interfaces, " +
"and objects."));
}
public void UndefinedFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...undefinedFragment
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified fragment `undefinedFragment` " +
"does not exist.",
t.Message));
}
public void ScalarSelectionsNotAllowedOnInt()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
barkVolume {
sinceWhen
}
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"`barkVolume` is a scalar field. Selections on scalars " +
"or enums are never allowed, because they are the leaf " +
"nodes of any GraphQL query."));
}
public void DuplicateFragments()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...fragmentOne
}
}
fragment fragmentOne on Dog {
name
}
fragment fragmentOne on Dog {
owner {
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"There are multiple fragments with the name `fragmentOne`.",
t.Message));
}
public void UnusedFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment nameFragment on Dog { # unused
name
}
{
dog {
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified fragment `nameFragment` " +
"is not used within the current document.", t.Message));
}
public void InvalidFieldArgName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment invalidArgName on Dog {
doesKnowCommand(command: CLEAN_UP_HOUSE)
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The argument `dogCommand` is required and does not " +
"allow null values.",
t.Message),
t => Assert.Equal(
"The argument `command` does not exist.", t.Message),
t => Assert.Equal(
"The specified fragment `invalidArgName` " +
"is not used within the current document.",
t.Message));
}
public ProjectController(
IOrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IStackRepository stackRepository,
IEventRepository eventRepository,
ITokenRepository tokenRepository,
IQueue <WorkItemData> workItemQueue,
BillingManager billingManager,
SlackService slackService,
IMapper mapper,
IQueryValidator validator,
AppOptions options,
ILoggerFactory loggerFactory
) : base(projectRepository, mapper, validator, loggerFactory)
{
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_stackRepository = stackRepository;
_eventRepository = eventRepository;
_tokenRepository = tokenRepository;
_workItemQueue = workItemQueue;
_billingManager = billingManager;
_slackService = slackService;
_options = options;
}
public CreateSubscriptionCommand(
IQueryValidator queryValidator,
IEntityById entityById,
IRepository<Subscription> repository)
{
this.queryValidator = queryValidator;
this.entityById = entityById;
this.repository = repository;
}
public CreateSubscriptionCommand(
IQueryValidator queryValidator,
IEntityById entityById,
IRepository <Subscription> repository)
{
this.queryValidator = queryValidator;
this.entityById = entityById;
this.repository = repository;
}
public void QueriesWithInvalidVariableTypes()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(@"
query takesCat($cat: Cat) {
# ...
}
query takesDogBang($dog: Dog!) {
# ...
}
query takesListOfPet($pets: [Pet]) {
# ...
}
query takesCatOrDog($catOrDog: CatOrDog) {
# ...
}
");
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
QueryValidationResult result =
queryValidator.Validate(schema, query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The following variables were not used: cat.",
t.Message),
t => Assert.Equal(
"The following variables were not used: dog.",
t.Message),
t => Assert.Equal(
"The following variables were not used: pets.",
t.Message),
t => Assert.Equal(
"The following variables were not used: catOrDog.",
t.Message),
t => Assert.Equal(
"The type of variable `cat` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `dog` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `pets` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `catOrDog` is not an input type.",
t.Message));
}
public CreateSubscriptionCommand CreateCommand(
IQueryValidator isQueryValid = null,
IEntityById entityById = null,
IRepository <Subscription> repository = null)
{
return(new CreateSubscriptionCommand(
isQueryValid ?? Mock.Of <IQueryValidator>(qv => qv.IsValid(It.IsAny <string>())),
entityById ?? Mock.Of <IEntityById>(eb => eb.Exist <Topic>(It.IsAny <Identity>())),
repository ?? Mock.Of <IRepository <Subscription> >()));
}
public CreateSubscriptionCommand CreateCommand(
IQueryValidator isQueryValid = null,
IEntityById entityById = null,
IRepository<Subscription> repository = null)
{
return new CreateSubscriptionCommand(
isQueryValid ?? Mock.Of<IQueryValidator>(qv => qv.IsValid(It.IsAny<string>())),
entityById ?? Mock.Of<IEntityById>(eb => eb.Exist<Topic>(It.IsAny<Identity>())),
repository ?? Mock.Of<IRepository<Subscription>>());
}
public ValidateQueryMiddleware(
QueryDelegate next,
IQueryValidator validator,
Cache <QueryValidationResult> validatorCache)
{
_next = next ??
throw new ArgumentNullException(nameof(next));
_validator = validator ??
throw new ArgumentNullException(nameof(validator));
_validatorCache = validatorCache ??
new Cache <QueryValidationResult>(Defaults.CacheSize);
}
public UpdateSubscriptionCommand CreateCommand(
IEntityById entityById = null,
IQueryValidator queryValidator = null,
IRepository <Subscription> repository = null
)
{
return(new UpdateSubscriptionCommand(
entityById ?? Mock.Of <IEntityById>(eb => eb.Exist <Subscription>(It.IsAny <Identity>()) == true),
queryValidator ?? Mock.Of <IQueryValidator>(qv => qv.IsValid(It.IsAny <string>()) == true),
repository ?? Mock.Of <IRepository <Subscription> >()
));
}
protected QueryHandler(IBus bus,
IQueryValidator <T> queryValidator,
IErrorEventEmitter <T, E, F> errorEventEmitter,
IQueryHandler <T, R> handler,
ILogger logger)
{
_bus = bus;
_queryValidator = queryValidator;
_errorEventEmitter = errorEventEmitter;
_logger = logger;
_handler = handler;
}
public UpdateSubscriptionCommand CreateCommand(
IEntityById entityById = null,
IQueryValidator queryValidator = null,
IRepository<Subscription> repository = null
)
{
return new UpdateSubscriptionCommand(
entityById ?? Mock.Of<IEntityById>(eb => eb.Exist<Subscription>(It.IsAny<Identity>()) == true),
queryValidator ?? Mock.Of<IQueryValidator>(qv => qv.IsValid(It.IsAny<string>()) == true),
repository ?? Mock.Of<IRepository<Subscription>>()
);
}
public void QueryIsNull()
{
// arrange
Schema schema = ValidationUtils.CreateSchema();
IQueryValidator queryValidator = CreateValidator();
// act
Action a = () => queryValidator.Validate(schema, null);
// assert
Assert.Throws <ArgumentNullException>(a);
}
/// <summary>
/// Initializes a new instance of <see cref="QueryCoordinator"/>
/// </summary>
/// <param name="typeDiscoverer"><see cref="ITypeDiscoverer"/> to use for discovering <see cref="IQueryProviderFor{T}"/> implementations</param>
/// <param name="container"><see cref="IContainer"/> for getting instances of <see cref="IQueryProviderFor{T}">query providers</see></param>
/// <param name="fetchingSecurityManager"><see cref="IFetchingSecurityManager"/> to use for securing <see cref="IQuery">queries</see></param>
/// <param name="validator"><see cref="IQueryValidator"/> to use for validating <see cref="IQuery">queries</see></param>
/// <param name="filters"><see cref="IReadModelFilters">Filters</see> used to filter any of the read models coming back after a query</param>
public QueryCoordinator(
ITypeDiscoverer typeDiscoverer,
IContainer container,
IFetchingSecurityManager fetchingSecurityManager,
IQueryValidator validator,
IReadModelFilters filters)
{
_typeDiscoverer = typeDiscoverer;
_container = container;
_validator = validator;
_filters = filters;
_fetchingSecurityManager = fetchingSecurityManager;
DiscoverQueryTypesPerTargetType();
}
private async Task<object> GetResult(IHttpContext context, IDictionary<string, string> routeArgs,
object service, MethodInfo method, ParameterInfo[] methodParams, IQueryValidator argResolver)
{
var urlArgs = new Dictionary<string, string>();
var paramSource = await GetParamSource(context.Request);
foreach (var param in paramSource.Split(new[] { '?', '&' }, StringSplitOptions.RemoveEmptyEntries))
{
var tokens = param.Split('=');
if (tokens.Length != 2)
return Error(context, "Invalid query string");
urlArgs.Add(tokens[0].ToLower(), Uri.UnescapeDataString(tokens[1]));
}
var methodArgs = new object[methodParams.Length];
if (argResolver != null)
{
var error = await argResolver.Validate(context, urlArgs);
if (error != null)
return error;
}
for (var i = 0; i < methodArgs.Length; i++)
{
var param = methodParams[i];
var argResult = TryGetArg(context, param, urlArgs, routeArgs, argResolver);
if (argResult is RouteError)
return argResult;
methodArgs[i] = argResult;
}
var result = method.Invoke(service, methodArgs);
var task = result as Task;
if (task == null)
return result;
await task;
PropertyInfo getter;
if (m_taskResultLookup.TryGetValue(task.GetType(), out getter))
return getter.GetValue(task);
else
return null;
}
public QueryParser(IQueryValidator queryValidator,
IDirectoryInfoProcessor directoryInfoProcessor)
{
_queryValidator = queryValidator;
_directoryInfoProcessor = directoryInfoProcessor;
}
private object TryGetArg(IHttpContext context, ParameterInfo param, IDictionary<string, string> urlArgs,
IDictionary<string, string> routeArgs, IQueryValidator argResolver)
{
var type = param.ParameterType;
if (type == typeof(IHttpContext))
return context;
var paramName = param.Name.ToLower();
string argValue;
var gotValue = urlArgs.TryGetValue(paramName, out argValue)
|| (routeArgs != null && routeArgs.TryGetValue(paramName, out argValue));
if (!gotValue)
{
object defaultValue;
if (param.TryGetDefaultValue(out defaultValue))
return defaultValue;
if (Nullable.GetUnderlyingType(param.ParameterType) != null)
return null;
return Error(context, "Missing param '{0}'", paramName);
}
if (string.IsNullOrEmpty(argValue))
return Error(context, "Empty param '{0}'", paramName);
object parsedArg;
if (!m_argParser.TryParse(type, argValue, out parsedArg))
return Error(context, "Param '{0}' is invalid", paramName);
return parsedArg;
}
