public async Task ExecutePublishDocumentServer_With_SchemaFile_Handler()
{
// arrange
var handler = new PublishSchemaDocumentHandler(
Storage, SchemaRepository, PublishSchemaEventSender);
using var service = new PublishDocumentService(
PublishDocumentMessageReceiver, new
IPublishDocumentHandler[] { handler });
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
var message = new PublishDocumentMessage(
"ghi", environment.Id, schema.Id, Array.Empty <Tag>());
IFileContainer fileContainer = await Storage.CreateContainerAsync("ghi");
using (Stream stream = await fileContainer.CreateFileAsync("schema.graphql"))
{
byte[] buffer = Encoding.UTF8.GetBytes(@"
type Query {
foo: String
}
");
await stream.WriteAsync(buffer, 0, buffer.Length);
}
await PublishDocumentMessageSender.SendAsync(message);
// act
await service.StartAsync(default);
public async Task PublishSchema()
{
// arrange
var serializer = new IdSerializer();
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"mutation(
$schemaName: String!
$environmentName: String!
$sourceText: String!
$version: String!) {
publishSchema(input: {
schemaName: $schemaName
environmentName: $environmentName
sourceText: $sourceText
tags: [ { key: ""version"" value: $version } ]
clientMutationId: ""ghi"" }) {
sessionId
clientMutationId
}
}")
.SetVariableValue("schemaName", "abc")
.SetVariableValue("environmentName", "abc")
.SetVariableValue("sourceText", "type Query { a: String }")
.SetVariableValue("version", "1.0.0")
.Create());
// assert
result.MatchSnapshot(o =>
o.Assert(fo =>
Assert.NotNull(fo.Field <string>("Data.publishSchema.sessionId"))));
Assert.Collection(ReceivedMessages,
t =>
{
PublishDocumentMessage message = Assert.IsType <PublishDocumentMessage>(t);
Assert.Equal(schema.Id, message.SchemaId);
Assert.Equal(environment.Id, message.EnvironmentId);
Assert.Equal(DocumentType.Schema, message.Type);
Assert.Null(message.ClientId);
Assert.NotNull(message.SessionId);
Assert.Collection(message.Tags,
t =>
{
Assert.Equal("version", t.Key);
Assert.Equal("1.0.0", t.Value);
});
});
}
private async Task HandleInternalAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
var issueLogger = new IssueLogger(message.SessionId, _eventSender);
try
{
IFileContainer fileContainer =
await _fileStorage.GetContainerAsync(message.SessionId).ConfigureAwait(false);
IEnumerable <IFile> files =
await fileContainer.GetFilesAsync(cancellationToken).ConfigureAwait(false);
IFile schemaFile = files.Single();
DocumentNode?schemaDocument = await TryParseSchemaAsync(
schemaFile, issueLogger, cancellationToken)
.ConfigureAwait(false);
string formattedSourceText = schemaDocument is { }
? PrintSchema(schemaDocument)
: await ReadSchemaSourceTextAsync(
schemaFile, cancellationToken)
.ConfigureAwait(false);
DocumentHash documentHash = DocumentHash.FromSourceText(formattedSourceText);
SchemaVersion?schemaVersion =
await _schemaRepository.GetSchemaVersionByHashAsync(
documentHash.Hash, cancellationToken)
.ConfigureAwait(false);
if (schemaVersion is null)
{
await PublishNewSchemaVersionAsync(
message,
schemaDocument,
formattedSourceText,
issueLogger,
cancellationToken)
.ConfigureAwait(false);
}
else
{
await PublishExistingSchemaVersionAsync(
message,
schemaDocument,
schemaVersion,
issueLogger,
cancellationToken)
.ConfigureAwait(false);
}
await fileContainer.DeleteAsync(cancellationToken).ConfigureAwait(false);
}
public Task HandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
return(HandleInternalAsync(message, cancellationToken));
}
private async Task HandleInternalAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
var logger = new IssueLogger(message.SessionId, _eventSender);
try
{
var documents = new List <QueryDocumentInfo>();
IReadOnlyList <Guid> queryIds = Array.Empty <Guid>();
ISchema?schema =
await SchemaHelper.TryLoadSchemaAsync(
SchemaRepository,
FileStorage,
message.SchemaId,
message.EnvironmentId,
logger,
cancellationToken)
.ConfigureAwait(false);
IFileContainer fileContainer = await FileStorage.GetContainerAsync(
message.SessionId, cancellationToken)
.ConfigureAwait(false);
if (schema is { })
{
queryIds = await ProcessDocumentsAsync(
message.SchemaId,
schema,
fileContainer,
message.Documents,
documents,
logger,
cancellationToken)
.ConfigureAwait(false);
}
Guid clientVersionId = await AddClientVersionAsync(
message, queryIds, cancellationToken)
.ConfigureAwait(false);
await AddEnvironmentPublishReport(
clientVersionId, message.EnvironmentId, logger, cancellationToken)
.ConfigureAwait(false);
await fileContainer.DeleteAsync(
cancellationToken)
.ConfigureAwait(false);
}
public async Task HandleMessage()
{
// arrange
string sessionId = await SessionCreator.CreateSessionAsync();
var handler = new PublishNewSchemaDocumentHandler(
Storage, SchemaRepository, PublishSchemaEventSender);
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
var message = new PublishDocumentMessage(
sessionId,
environment.Id,
schema.Id,
"externalId",
Array.Empty <DocumentInfo>(),
Array.Empty <Tag>());
IFileContainer fileContainer = await Storage.CreateContainerAsync(sessionId);
byte[] buffer = Encoding.UTF8.GetBytes(@"
type Query {
foo: String
}
");
await fileContainer.CreateFileAsync("schema.graphql", buffer, 0, buffer.Length);
// act
await handler.HandleAsync(message, default);
// assert
var list = new List <PublishDocumentEvent>();
using var cts = new CancellationTokenSource(5000);
IAsyncEnumerable <PublishDocumentEvent> eventStream =
await PublishSchemaEventReceiver.SubscribeAsync(sessionId, cts.Token);
await foreach (PublishDocumentEvent eventMessage in
eventStream.WithCancellation(cts.Token))
{
list.Add(eventMessage);
}
list.MatchSnapshot(matchOption =>
matchOption.Assert(fieldOption =>
Assert.Equal(sessionId, fieldOption.Field <string>("[0].SessionId"))));
}
public Task HandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.ClientId is null)
{
throw new ArgumentException(
"The client id is not allowed to be null.",
nameof(message));
}
return(HandleInternalAsync(message, cancellationToken));
}
public async Task HandleMessage()
{
// arrange
var handler = new PublishSchemaDocumentHandler(
Storage, SchemaRepository, PublishSchemaEventSender);
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
var message = new PublishDocumentMessage(
"ghi", environment.Id, schema.Id, Array.Empty <Tag>());
IFileContainer fileContainer = await Storage.CreateContainerAsync("ghi");
using (Stream stream = await fileContainer.CreateFileAsync("schema.graphql"))
{
byte[] buffer = Encoding.UTF8.GetBytes(@"
type Query {
foo: String
}
");
await stream.WriteAsync(buffer, 0, buffer.Length);
}
// act
await handler.HandleAsync(message, default);
// assert
var list = new List <PublishSchemaEvent>();
using var cts = new CancellationTokenSource(5000);
IAsyncEnumerable <PublishSchemaEvent> eventStream =
await PublishSchemaEventReceiver.SubscribeAsync("ghi", cts.Token);
await foreach (PublishSchemaEvent eventMessage in
eventStream.WithCancellation(cts.Token))
{
list.Add(eventMessage);
}
list.MatchSnapshot();
}
public async ValueTask <bool> CanHandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
if (message is { Type : DocumentType.Schema })
public async ValueTask <bool> CanHandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
if (message is { Type : DocumentType.Query, ExternalId : { } } ||
public abstract ValueTask <bool> CanHandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken);
public override async ValueTask <bool> CanHandleAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
if (message is { Type : DocumentType.Query })
