public async ValueTask InvokeAsync(IRequestContext context) { if (context.Document is null) { context.Result = StateInvalidForDocumentValidation(); } else { if (context.ValidationResult is null) { using (_diagnosticEvents.ValidateDocument(context)) { context.ValidationResult = _documentValidator.Validate( context.Schema, context.Document, context.ContextData); } } if (context.ValidationResult is { HasErrors : true } validationResult) { context.Result = QueryResultBuilder.CreateError( validationResult.Errors, new Dictionary <string, object?> { { WellKnownContextData.ValidationErrors, true } }); _diagnosticEvents.ValidationErrors(context, validationResult.Errors); }
private IReadOnlyList <HCError> ValidateQueryDocuments(ISchema schema) { var errors = new List <HCError>(); try { var serviceCollection = new ServiceCollection(); serviceCollection.AddValidation(); IDocumentValidator validator = serviceCollection.BuildServiceProvider() .GetService <IDocumentValidatorFactory>().CreateValidator(); foreach (DocumentInfo documentInfo in _queries.Values) { DocumentValidatorResult validationResult = validator.Validate(schema, documentInfo.Document); if (validationResult.HasErrors) { foreach (HCError error in validationResult.Errors) { errors.Add(HCErrorBuilder.FromError(error) .SetExtension("fileName", documentInfo.FileName) .SetExtension("document", documentInfo.Document) .Build()); } } } } catch (GeneratorException ex) { errors.AddRange(ex.Errors); } return(errors); }
public async ValueTask InvokeAsync(IRequestContext context) { if (context.Document is null) { // TODO : ErrorHelper context.Result = QueryResultBuilder.CreateError( ErrorBuilder.New() .SetMessage("Cannot Validate") .Build()); } else { if (context.ValidationResult is null) { using (_diagnosticEvents.ValidateDocument(context)) { context.ValidationResult = _documentValidator.Validate(context.Schema, context.Document !); } } if (context.ValidationResult is { HasErrors : true } validationResult) { context.Result = QueryResultBuilder.CreateError(validationResult.Errors); _diagnosticEvents.ValidationErrors(context, validationResult.Errors); }
public virtual CaptureResponse Capture(XDocument xmlDocument) { var startDate = SystemContext.Clock.Now; _documentValidator.Validate(xmlDocument); var events = _documentParser.Parse(xmlDocument.Root); var currentUser = _userProvider.GetCurrentUser(); var request = new EpcisRequest { RecordTime = SystemContext.Clock.Now, DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value), User = currentUser }; foreach (var @event in events) { request.AddEvent(@event); } _requestPersister.Persist(request); return(new CaptureResponse { EventCount = request.Events.Count, CaptureStartDateUtc = startDate, CaptureEndDateUtc = SystemContext.Clock.Now, EventIds = request.Events.Select(e => e.Id.ToString()).ToArray() }); }
public async Task <ExecutionResult> ExecuteAsync( ISchema schema, object root, string query, string operationName, Inputs inputs = null, object userContext = null, CancellationToken cancellationToken = default(CancellationToken), IEnumerable <IValidationRule> rules = null) { var result = new ExecutionResult(); try { var document = _documentBuilder.Build(query); var validationResult = _documentValidator.Validate(query, schema, document, rules); if (validationResult.IsValid) { var context = BuildExecutionContext(schema, root, document, operationName, inputs, userContext, cancellationToken); if (context.Errors.Any()) { result.Errors = context.Errors; return(result); } result.Data = await ExecuteOperationAsync(context).ConfigureAwait(false); if (context.Errors.Any()) { result.Errors = context.Errors; } } else { result.Data = null; result.Errors = validationResult.Errors; } return(result); } catch (Exception exc) { if (result.Errors == null) { result.Errors = new ExecutionErrors(); } result.Data = null; result.Errors.Add(new ExecutionError(exc.Message, exc)); return(result); } }
private void ValidateDocument(string document) { if (string.IsNullOrWhiteSpace(document)) { throw new EstablishmentValidatorException(Properties.Resources.EstablishmentDocumentError); } if (!_documentValidator.Validate(document)) { throw new EstablishmentValidatorException(Properties.Resources.EstablishmentDocumentInvalidErro); } }
public void DocumentIsNull() { // arrange Schema schema = ValidationUtils.CreateSchema(); IDocumentValidator queryValidator = CreateValidator(); // act Action a = () => queryValidator.Validate(schema, null !); // assert Assert.Throws <ArgumentNullException>(a); }
private void ValidateDocument(OwnerPet entity) { if (string.IsNullOrWhiteSpace(entity.Document)) { throw new OwnerPetValidatorException(Properties.Resources.OwnerPetDocumentError); } if (!_documentValidator.Validate(entity.Document)) { throw new OwnerPetValidatorException(Properties.Resources.OwnerPetDocumentInvalidError); } }
private void ExpectValid(ISchema schema, IDocumentValidator validator, string sourceText) { // arrange schema ??= ValidationUtils.CreateSchema(); validator ??= CreateValidator(); DocumentNode query = Utf8GraphQLParser.Parse(sourceText); // act DocumentValidatorResult result = validator.Validate(schema, query); // assert Assert.Empty(result.Errors); }
public void SchemaIsNull() { // arrange Schema schema = ValidationUtils.CreateSchema(); IDocumentValidator queryValidator = CreateValidator(); // act // act Action a = () => queryValidator.Validate(null, new DocumentNode(null, new List <IDefinitionNode>())); // assert Assert.Throws <ArgumentNullException>(a); }
public virtual IEnumerable <string> Capture(XDocument document) { _validator.Validate(document); var masterdataList = _masterdataParser.Parse(document.Root); var currentUser = _userProvider.GetCurrentUser(); foreach (var masterdata in masterdataList) { _masterdataRepository.Store(masterdata); } return(masterdataList.Select(x => x.Id)); }
private static bool TryValidateRequest( ISchema schema, IReadOnlyList <GraphQLFile> executableFiles, Dictionary <ISyntaxNode, string> fileLookup, List <IError> errors) { IDocumentValidator validator = CreateDocumentValidator(); DocumentNode document = MergeDocuments(executableFiles); DocumentValidatorResult validationResult = validator.Validate(schema, document); if (validationResult.HasErrors) { errors.AddRange( validationResult.Errors.Select( error => error.WithFileReference(fileLookup))); return(false); } return(true); }
public void DuplicatesWillBeIgnoredOnFieldMerging() { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( FileResource.Open("InvalidIntrospectionQuery.graphql")); var originalOperation = ((OperationDefinitionNode)document.Definitions[0]); OperationDefinitionNode operationWithDuplicates = originalOperation.WithSelectionSet( originalOperation.SelectionSet.WithSelections( new List <ISelectionNode> { originalOperation.SelectionSet.Selections[0], originalOperation.SelectionSet.Selections[0] })); document = document.WithDefinitions( new List <IDefinitionNode>(document.Definitions.Skip(1)) { operationWithDuplicates }); ServiceProvider services = new ServiceCollection() .AddValidation() .Services .BuildServiceProvider(); IDocumentValidatorFactory factory = services.GetRequiredService <IDocumentValidatorFactory>(); IDocumentValidator validator = factory.CreateValidator(); // act DocumentValidatorResult result = validator.Validate(schema, document); // assert Assert.False(result.HasErrors); }
private void ExpectErrors( ISchema schema, IDocumentValidator validator, string sourceText, params Action <IError>[] elementInspectors) { // arrange schema ??= ValidationUtils.CreateSchema(); validator ??= CreateValidator(); DocumentNode query = Utf8GraphQLParser.Parse(sourceText); // act DocumentValidatorResult result = validator.Validate(schema, query); // assert Assert.NotEmpty(result.Errors); if (elementInspectors.Length > 0) { Assert.Collection(result.Errors, elementInspectors); } result.Errors.MatchSnapshot(); }
public async ValueTask InvokeAsync(IRequestContext context) { if (context.Document is null) { context.Result = StateInvalidForDocumentValidation(); } else { using (_diagnosticEvents.ValidateDocument(context)) { context.ValidationResult = _documentValidator.Validate( context.Schema, context.Document, context.ContextData, context.ValidationResult is not null); } if (context.IsValidDocument) { await _next(context).ConfigureAwait(false); } else { DocumentValidatorResult validationResult = context.ValidationResult; context.Result = QueryResultBuilder.CreateError( validationResult.Errors, new Dictionary <string, object?> { { WellKnownContextData.ValidationErrors, true } }); _diagnosticEvents.ValidationErrors(context, validationResult.Errors); } } }
public virtual IEnumerable <string> Capture(XDocument xmlDocument) { _documentValidator.Validate(xmlDocument); var events = _documentParser.Parse(xmlDocument.Root); var currentUser = _userProvider.GetCurrentUser(); var request = new EpcisRequest { RecordTime = SystemContext.Clock.Now, DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value), SubscriptionId = TryExtractSubscriptionId(xmlDocument), User = currentUser }; foreach (var @event in events) { request.AddEvent(@event); } _requestPersister.Persist(request); return(request.Events.Select(e => e.Id.ToString())); }
public async Task <ExecutionResult> ExecuteAsync(ExecutionOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } var metrics = new Metrics(options.EnableMetrics); metrics.Start(options.OperationName); options.Schema.FieldNameConverter = options.FieldNameConverter; ExecutionResult result = null; try { ValidateOptions(options); if (!options.Schema.Initialized) { using (metrics.Subject("schema", "Initializing schema")) { if (options.SetFieldMiddleware) { options.FieldMiddleware.ApplyTo(options.Schema); } options.Schema.Initialize(); } } var document = options.Document; using (metrics.Subject("document", "Building document")) { if (document == null) { document = _documentBuilder.Build(options.Query); } } var operation = GetOperation(options.OperationName, document); metrics.SetOperationName(operation?.Name); if (operation == null) { throw new ExecutionError("Unable to determine operation from query."); } IValidationResult validationResult; using (metrics.Subject("document", "Validating document")) { validationResult = _documentValidator.Validate( options.Query, options.Schema, document, options.ValidationRules, options.UserContext, options.Inputs); } if (options.ComplexityConfiguration != null && validationResult.IsValid) { using (metrics.Subject("document", "Analyzing complexity")) _complexityAnalyzer.Validate(document, options.ComplexityConfiguration); } foreach (var listener in options.Listeners) { await listener.AfterValidationAsync( options.UserContext, validationResult, options.CancellationToken) .ConfigureAwait(false); } if (!validationResult.IsValid) { return(new ExecutionResult() { Errors = validationResult.Errors }); } var context = BuildExecutionContext( options.Schema, options.Root, document, operation, options.Inputs, options.UserContext, options.CancellationToken, metrics, options.Listeners); if (context.Errors.Any()) { return(new ExecutionResult() { Errors = context.Errors }); } using (metrics.Subject("execution", "Executing operation")) { foreach (var listener in context.Listeners) { await listener.BeforeExecutionAsync(context.UserContext, context.CancellationToken) .ConfigureAwait(false); } IExecutionStrategy executionStrategy = SelectExecutionStrategy(context); if (executionStrategy == null) { throw new InvalidOperationException("Invalid ExecutionStrategy!"); } var task = executionStrategy.ExecuteAsync(context) .ConfigureAwait(false); foreach (var listener in context.Listeners) { await listener.BeforeExecutionAwaitedAsync(context.UserContext, context.CancellationToken) .ConfigureAwait(false); } result = await task; foreach (var listener in context.Listeners) { await listener.AfterExecutionAsync(context.UserContext, context.CancellationToken) .ConfigureAwait(false); } } if (context.Errors.Any()) { result.Errors = context.Errors; } } catch (Exception ex) { result = new ExecutionResult { Errors = new ExecutionErrors() { new ExecutionError(ex.Message, ex) } }; } finally { result = result ?? new ExecutionResult(); result.ExposeExceptions = options.ExposeExceptions; result.Perf = metrics.Finish()?.ToArray(); } return(result); }
private DocumentValidatorResult Validate(ISchema schema, DocumentNode document) { return(_validator.Validate(schema, document)); }
public void Setup() { _validator.Validate(_schema, _introspectionQuery); }
public async Task <ExecutionResult> ExecuteAsync(ExecutionOptions config) { var metrics = new Metrics(); metrics.Start(config.OperationName); config.Schema.FieldNameConverter = config.FieldNameConverter; var result = InitializeResult(config); try { ValidateOptions(config); if (!config.Schema.Initialized) { using (metrics.Subject("schema", "Initializing schema")) { config.FieldMiddleware.ApplyTo(config.Schema); config.Schema.Initialize(); } } var document = config.Document; using (metrics.Subject("document", "Building document")) { if (document == null) { document = _documentBuilder.Build(config.Query); } } result.Document = document; var operation = GetOperation(config.OperationName, document); result.Operation = operation; metrics.SetOperationName(operation?.Name); if (operation == null) { throw new ExecutionError("Unable to determine operation from query."); } if (config.ComplexityConfiguration != null) { using (metrics.Subject("document", "Analyzing complexity")) _complexityAnalyzer.Validate(document, config.ComplexityConfiguration); } IValidationResult validationResult; using (metrics.Subject("document", "Validating document")) { validationResult = _documentValidator.Validate( config.Query, config.Schema, document, config.ValidationRules, config.UserContext); } foreach (var listener in config.Listeners) { await listener.AfterValidationAsync( config.UserContext, validationResult, config.CancellationToken) .ConfigureAwait(false); } if (validationResult.IsValid) { var context = BuildExecutionContext( config.Schema, config.Root, document, operation, config.Inputs, config.UserContext, config.CancellationToken, metrics); if (context.Errors.Any()) { result.Errors = context.Errors; return(result); } using (metrics.Subject("execution", "Executing operation")) { foreach (var listener in config.Listeners) { await listener.BeforeExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false); } await OnExecution(config, context, result); foreach (var listener in config.Listeners) { await listener.AfterExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false); } } if (context.Errors.Any()) { result.Errors = context.Errors; } } else { OnValidationError(validationResult, result); } return(result); } catch (Exception exc) { OnError(exc, result); return(result); } finally { result.Perf = metrics.Finish().ToArray(); } }