public async Task GetPublishReportBySchemaVersionIdAndEnvironmentId()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id, "foo", "bar", Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id, Guid.NewGuid(), Array.Empty <Issue>(),
PublishState.Published, DateTime.UtcNow);
await publishReports.InsertOneAsync(initialReport, options : null, default);
var repository = new SchemaRepository(schemas, versions, publishReports);
// act
SchemaPublishReport retrieved = await repository.GetPublishReportAsync(
initialReport.SchemaVersionId, initialReport.EnvironmentId);
// assert
Assert.Equal(initialReport.Id, retrieved.Id);
}
public async Task AddPublishReport()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id, "foo", "bar", Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id, Guid.NewGuid(), Array.Empty <Issue>(),
PublishState.Published, DateTime.UtcNow);
var repository = new SchemaRepository(schemas, versions, publishReports);
// act
await repository.AddPublishReportAsync(initialReport);
// assert
IReadOnlyDictionary <Guid, SchemaPublishReport> retrieved =
await repository.GetPublishReportsAsync(new[] { initialReport.Id });
Assert.True(retrieved.ContainsKey(initialReport.Id));
}
public async Task SetPublishReportAsync(
SchemaPublishReport publishReport,
CancellationToken cancellationToken = default)
{
try
{
await _publishReports.ReplaceOneAsync(
Builders <SchemaPublishReport> .Filter.Eq(t => t.Id, publishReport.Id),
publishReport,
options : new ReplaceOptions {
IsUpsert = true
},
cancellationToken)
.ConfigureAwait(false);
}
catch (MongoWriteException ex)
when(ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
// TODO : resources
throw new DuplicateKeyException(
"A schema publish report was already created for the specified " +
"schema version and environment.",
ex);
}
}
public PublishSchemaPayload(
SchemaVersion version,
SchemaPublishReport report,
string?clientMutationId)
{
Version = version;
Report = report;
ClientMutationId = clientMutationId;
}
public async Task UpdatePublishReport()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id,
"foo",
DocumentHash.FromSourceText("bar"),
Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id, Guid.NewGuid(), Array.Empty <Issue>(),
PublishState.Published, DateTime.UtcNow);
await publishReports.InsertOneAsync(initialReport, options : null, default);
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
// act
await repository.SetPublishReportAsync(new SchemaPublishReport(
initialReport.Id, initialReport.SchemaVersionId,
initialReport.EnvironmentId, initialReport.Issues,
PublishState.Rejected, DateTime.UtcNow));
// assert
IReadOnlyDictionary <Guid, SchemaPublishReport> retrieved =
await repository.GetPublishReportsAsync(new[] { initialReport.Id });
Assert.Equal(PublishState.Rejected, retrieved[initialReport.Id].State);
}
public async Task GetPublishReports()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id,
"foo",
new DocumentHash("baz", "baz", HashFormat.Hex),
Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id,
Guid.NewGuid(),
Array.Empty <Issue>(),
PublishState.Published,
DateTime.UtcNow);
await publishReports.InsertOneAsync(initialReport, options : null, default);
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
// act
SchemaPublishReport retrieved = repository.GetPublishReports()
.Where(t => t.Id == initialReport.Id)
.FirstOrDefault();
// assert
Assert.Equal(initialReport.State, retrieved.State);
}
public async Task AddPublishReportAsync(
SchemaPublishReport publishReport,
CancellationToken cancellationToken = default)
{
try
{
await _publishReports.InsertOneAsync(
publishReport,
options : null,
cancellationToken)
.ConfigureAwait(false);
}
catch (MongoWriteException ex)
when(ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
// TODO : resources
throw new DuplicateKeyException(
"A schema publish report was already created for the specified " +
"schema version and environment.",
ex);
}
}
public async Task SetPublishReportAsync(
SchemaPublishReport publishReport,
CancellationToken cancellationToken = default)
{
UpdateResult result = await _publishReports.UpdateOneAsync(
Builders <SchemaPublishReport> .Filter.And(
Builders <SchemaPublishReport> .Filter.Eq(
t => t.EnvironmentId,
publishReport.EnvironmentId),
Builders <SchemaPublishReport> .Filter.Eq(
t => t.SchemaVersionId,
publishReport.SchemaVersionId)),
Builders <SchemaPublishReport> .Update.Combine(
Builders <SchemaPublishReport> .Update.SetOnInsert(
t => t.Id, publishReport.Id),
Builders <SchemaPublishReport> .Update.SetOnInsert(
t => t.EnvironmentId, publishReport.EnvironmentId),
Builders <SchemaPublishReport> .Update.SetOnInsert(
t => t.SchemaVersionId, publishReport.SchemaVersionId),
Builders <SchemaPublishReport> .Update.Set(
t => t.Issues, publishReport.Issues),
Builders <SchemaPublishReport> .Update.Set(
t => t.Published, publishReport.Published),
Builders <SchemaPublishReport> .Update.Set(
t => t.State, publishReport.State)),
options : new UpdateOptions {
IsUpsert = true
},
cancellationToken)
.ConfigureAwait(false);
if (!result.IsUpserted(publishReport.Id))
{
throw new RepositoryException("The schema publish report was not updated.");
}
}
public async Task <PublishSchemaPayload> PublishSchemaAsync(
PublishSchemaInput input,
[Service] ISchemaRepository schemaRepository,
[DataLoader] SchemaByNameDataLoader schemaDataLoader,
[DataLoader] EnvironmentByNameDataLoader environmentDataLoader,
CancellationToken cancellationToken)
{
Schema schema = await schemaDataLoader.LoadAsync(
input.SchemaName, cancellationToken)
.ConfigureAwait(false);
Environment environment = await environmentDataLoader.LoadAsync(
input.EnvironmentName, cancellationToken)
.ConfigureAwait(false);
SchemaVersion?schemaVersion;
string? hash = input.Hash;
if (hash is null)
{
if (input.SourceText is null)
{
throw new GraphQLException(
Resources.SchemaMutations_HashAndSourceTextAreNull);
}
using var sha = SHA256.Create();
hash = Convert.ToBase64String(sha.ComputeHash(
Encoding.UTF8.GetBytes(input.SourceText)));
}
schemaVersion = await schemaRepository.GetSchemaVersionAsync(
hash, cancellationToken)
.ConfigureAwait(false);
if (schemaVersion is null && input.SourceText is null)
{
throw new GraphQLException(
Resources.SchemaMutations_HashNotFound);
}
if (schemaVersion is null)
{
schemaVersion = await CreateSchemaVersionAsync(
input.SourceText !,
input.Tags ?? Array.Empty <TagInput>(),
schema,
schemaRepository,
cancellationToken)
.ConfigureAwait(false);
}
else
{
schemaVersion = await UpdateSchemaVersionAsync(
schemaVersion,
input.Tags ?? Array.Empty <TagInput>(),
schemaRepository,
cancellationToken)
.ConfigureAwait(false);
}
SchemaPublishReport report = await TryCreateReportAsync(
schemaVersion.Id,
environment.Id,
schemaRepository,
cancellationToken)
.ConfigureAwait(false);
return(new PublishSchemaPayload(schemaVersion, report, input.ClientMutationId));
}
public Task <SchemaVersion> GetSchemaVersionAsync(
[Parent] SchemaPublishReport report,
[DataLoader] SchemaVersionByIdDataLoader dataLoader,
CancellationToken cancellationToken) =>
dataLoader.LoadAsync(report.SchemaVersionId, cancellationToken);
public Task <Environment> GetEnvironmentAsync(
[Parent] SchemaPublishReport report,
[DataLoader] EnvironmentByIdDataLoader dataLoader,
CancellationToken cancellationToken) =>
dataLoader.LoadAsync(report.EnvironmentId, cancellationToken);
