Example #1
0
        public void ParseApiKeySecuritySchemeShouldSucceed()
        {
            using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "apiKeySecurityScheme.yaml")))
            {
                var yamlStream = new YamlStream();
                yamlStream.Load(new StreamReader(stream));
                var yamlNode = yamlStream.Documents.First().RootNode;

                var diagnostic = new OpenApiDiagnostic();
                var context    = new ParsingContext(diagnostic);

                var node = new MapNode(context, (YamlMappingNode)yamlNode);

                // Act
                var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);

                // Assert
                securityScheme.Should().BeEquivalentTo(
                    new OpenApiSecurityScheme
                {
                    Type = SecuritySchemeType.ApiKey,
                    Name = "api_key",
                    In   = ParameterLocation.Header
                });
            }
        }
Example #2
0
        public void ParseBearerSecuritySchemeShouldSucceed()
        {
            using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "bearerSecurityScheme.yaml")))
            {
                var yamlStream = new YamlStream();
                yamlStream.Load(new StreamReader(stream));
                var yamlNode = yamlStream.Documents.First().RootNode;

                var diagnostic = new OpenApiDiagnostic();
                var context    = new ParsingContext(diagnostic);

                var node = new MapNode(context, (YamlMappingNode)yamlNode);

                // Act
                var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);

                // Assert
                securityScheme.Should().BeEquivalentTo(
                    new OpenApiSecurityScheme
                {
                    Type         = SecuritySchemeType.Http,
                    Scheme       = "bearer",
                    BearerFormat = "JWT"
                });
            }
        }
Example #3
0
        public void ParseOpenIdConnectSecuritySchemeShouldSucceed()
        {
            using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "openIdConnectSecurityScheme.yaml")))
            {
                var yamlStream = new YamlStream();
                yamlStream.Load(new StreamReader(stream));
                var yamlNode = yamlStream.Documents.First().RootNode;

                var diagnostic = new OpenApiDiagnostic();
                var context    = new ParsingContext(diagnostic);

                var node = new MapNode(context, (YamlMappingNode)yamlNode);

                // Act
                var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);

                // Assert
                securityScheme.Should().BeEquivalentTo(
                    new OpenApiSecurityScheme
                {
                    Type             = SecuritySchemeType.OpenIdConnect,
                    Description      = "Sample Description",
                    OpenIdConnectUrl = new Uri("http://www.example.com")
                });
            }
        }
        public void ParseOAuth2SecuritySchemeShouldSucceed()
        {
            using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "oAuth2SecurityScheme.yaml")))
            {
                var yamlStream = new YamlStream();
                yamlStream.Load(new StreamReader(stream));
                var yamlNode = yamlStream.Documents.First().RootNode;

                var context    = new ParsingContext();
                var diagnostic = new OpenApiDiagnostic();

                var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);

                // Act
                var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);

                // Assert
                securityScheme.ShouldBeEquivalentTo(
                    new OpenApiSecurityScheme
                {
                    Type  = SecuritySchemeType.OAuth2,
                    Flows = new OpenApiOAuthFlows
                    {
                        Implicit = new OpenApiOAuthFlow
                        {
                            AuthorizationUrl = new Uri("https://example.com/api/oauth/dialog"),
                            Scopes           =
                            {
                                ["write:pets"] = "modify pets in your account",
                                ["read:pets"]  = "read your pets"
                            }
                        }
                    }
                });
            }
        }
        /// <summary>
        /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="OpenApiReference"/> object
        /// </summary>
        public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceable referencedObject)
        {
            referencedObject = null;

            if (reference == null)
            {
                return(false);
            }

            if (reference.IsExternal)
            {
                // TODO: need to read the external document and load the referenced object.
                throw new NotImplementedException(SRResource.LoadReferencedObjectFromExternalNotImplmented);
            }

            if (!reference.Type.HasValue)
            {
                throw new ArgumentException("Local reference must have type specified.");
            }

            // Special case for Tag
            if (reference.Type == ReferenceType.Tag)
            {
                foreach (var tag in _tags)
                {
                    if (tag.Name == reference.Id)
                    {
                        referencedObject = tag;
                        return(true);
                    }
                }

                referencedObject = new OpenApiTag {
                    Name = reference.Id
                };
                return(false);
            }

            var componentJsonPointer =
                new JsonPointer("#/components/" + reference.Type.GetDisplayName() + "/" + reference.Id);

            var node = _rootNode.Find(componentJsonPointer);

            switch (reference.Type)
            {
            case ReferenceType.Schema:
                referencedObject = OpenApiV3Deserializer.LoadSchema(node);
                break;

            case ReferenceType.Response:
                referencedObject = OpenApiV3Deserializer.LoadResponse(node);
                break;

            case ReferenceType.Parameter:
                referencedObject = OpenApiV3Deserializer.LoadParameter(node);
                break;

            case ReferenceType.Example:
                referencedObject = OpenApiV3Deserializer.LoadExample(node);
                break;

            case ReferenceType.RequestBody:
                referencedObject = OpenApiV3Deserializer.LoadRequestBody(node);
                break;

            case ReferenceType.Header:
                referencedObject = OpenApiV3Deserializer.LoadHeader(node);
                break;

            case ReferenceType.SecurityScheme:
                referencedObject = OpenApiV3Deserializer.LoadSecurityScheme(node);
                break;

            case ReferenceType.Link:
                referencedObject = OpenApiV3Deserializer.LoadLink(node);
                break;

            case ReferenceType.Callback:
                referencedObject = OpenApiV3Deserializer.LoadCallback(node);
                break;

            default:
                throw new OpenApiException(
                          string.Format(
                              SRResource.ReferenceV3HasInvalidValue,
                              reference.Type,
                              componentJsonPointer));
            }

            return(true);
        }