public async Task LoadDocumentIntoWorkspace()
        {
            // Create a reader that will resolve all references
            var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
            {
                ReferenceResolution  = ReferenceResolutionSetting.ResolveAllReferences,
                CustomExternalLoader = new MockLoader()
            });

            // Todo: this should be ReadAsync
            var stream = new MemoryStream();
            var doc    = @"openapi: 3.0.0
info:
  title: foo
  version: 1.0.0
paths: {}";
            var wr     = new StreamWriter(stream);

            wr.Write(doc);
            wr.Flush();
            stream.Position = 0;

            var result = await reader.ReadAsync(stream);

            Assert.NotNull(result.OpenApiDocument.Workspace);
        }
Esempio n. 2
0
        internal async Task LoadAsync(OpenApiReference reference, OpenApiDocument document)
        {
            _workspace.AddDocument(reference.ExternalResource, document);
            document.Workspace = _workspace;

            // Collect remote references by walking document
            var referenceCollector = new OpenApiRemoteReferenceCollector(document);
            var collectorWalker    = new OpenApiWalker(referenceCollector);

            collectorWalker.Walk(document);

            var reader = new OpenApiStreamReader(_readerSettings);

            // Walk references
            foreach (var item in referenceCollector.References)
            {
                // If not already in workspace, load it and process references
                if (!_workspace.Contains(item.ExternalResource))
                {
                    var input = await _loader.LoadAsync(new Uri(item.ExternalResource, UriKind.RelativeOrAbsolute));

                    var result = await reader.ReadAsync(input); // TODO merge _diagnositics
                    await LoadAsync(item, result.OpenApiDocument);
                }
            }
        }
        public async Task LoadTodoDocumentIntoWorkspace()
        {
            // Create a reader that will resolve all references
            var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
            {
                ReferenceResolution  = ReferenceResolutionSetting.ResolveAllReferences,
                CustomExternalLoader = new ResourceLoader()
            });

            ReadResult result;

            using (var stream = Resources.GetStream("V3Tests/Samples/OpenApiWorkspace/TodoMain.yaml"))
            {
                result = await reader.ReadAsync(stream);
            }

            Assert.NotNull(result.OpenApiDocument.Workspace);
            Assert.True(result.OpenApiDocument.Workspace.Contains("TodoComponents.yaml"));
            var referencedSchema = result.OpenApiDocument
                                   .Paths["/todos"]
                                   .Operations[OperationType.Get]
                                   .Responses["200"]
                                   .Content["application/json"]
                                   .Schema;

            Assert.Equal("object", referencedSchema.Type);
            Assert.Equal("string", referencedSchema.Properties["subject"].Type);
            Assert.False(referencedSchema.UnresolvedReference);

            var referencedParameter = result.OpenApiDocument
                                      .Paths["/todos"]
                                      .Operations[OperationType.Get]
                                      .Parameters
                                      .Where(p => p.Name == "filter").FirstOrDefault();

            Assert.Equal("string", referencedParameter.Schema.Type);
        }