private static async Task ExtractMetadataAsync(
UpgradeServiceAccessor services, SqlExecutor executor, SqlWorkerResult result, SqlWorkerTask task,
CancellationToken token)
{
var set = new MetadataSet();
var mapping = new MetadataMapping(services.StorageDriver, services.NameBuilder);
var metadataExtractor = new MetadataExtractor(mapping, executor);
foreach (var metadataTask in services.MappingResolver.GetMetadataTasks()
.Where(metadataTask => !ShouldSkipMetadataExtraction(mapping, result, metadataTask)))
{
try {
if (task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies))
{
await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataTypes))
{
await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataExtension))
{
await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwait(false);
}
}
catch (Exception exception) {
UpgradeLog.Warning(
Strings.LogFailedToExtractMetadataFromXYZ, metadataTask.Catalog, metadataTask.Schema, exception);
}
}
result.Metadata = set;
}
private void ValidateSchema(SqlWorkerTask task, SqlWorkerResult result)
{
var error = string.Format(ErrorMessage, task);
if (!task.HasFlag(SqlWorkerTask.ExtractSchema))
{
Assert.IsNull(result.Schema, error);
}
else
{
Assert.IsNotNull(result.Schema, error);
Assert.IsNotEmpty(result.Schema.Catalogs, error);
}
}
private void ValidateWorkerResult(SqlWorkerTask task)
{
var result = SqlWorker.Create(accessor, task).Invoke();
var error = string.Format(ErrorMessage, task);
ValidateSchema(task, result);
if (task == SqlWorkerTask.DropSchema)
{
Assert.IsTrue(result.Schema == null, error);
Assert.IsTrue(result.Metadata == null, error);
return;
}
ValidateMetadata(task, result, task.HasFlag(SqlWorkerTask.DropSchema));
}
private async Task ValidateWorkerResultAsync(SqlWorkerTask task)
{
var result = await SqlAsyncWorker.Create(accessor, task, CancellationToken.None).Invoke();
var error = string.Format(ErrorMessage, task);
ValidateSchema(task, result);
if (task == SqlWorkerTask.DropSchema)
{
Assert.IsTrue(result.Schema == null, error);
Assert.IsTrue(result.Metadata == null, error);
}
else
{
ValidateMetadata(task, result, task.HasFlag(SqlWorkerTask.DropSchema));
}
}
private void ValidateMetadata(SqlWorkerTask task, SqlWorkerResult result, bool isSchemaDropped)
{
var error = string.Format(ErrorMessage, task);
if (!IsMetdataMemberExtracted(task))
{
Assert.IsNull(result.Metadata);
}
else
{
Assert.That(result.Metadata.Types.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataTypes)), error);
Assert.That(result.Metadata.Assemblies.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies)), error);
Assert.That(result.Metadata.Extensions.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataExtension)), error);
}
}