Esempio n. 1
0
        public ChangedSecurityRequirementsBO Diff(
            IList <OpenApiSecurityRequirement> left, IList <OpenApiSecurityRequirement> right, DiffContextBO context)
        {
            left ??= new List <OpenApiSecurityRequirement>();
            right = right != null?GetCopy(right) : new List <OpenApiSecurityRequirement>();

            var changedSecurityRequirements = new ChangedSecurityRequirementsBO(left, right);

            foreach (var leftSecurity in left)
            {
                var rightSecOpt = Contains(right, leftSecurity);
                if (rightSecOpt == null)
                {
                    changedSecurityRequirements.Missing.Add(leftSecurity);
                }
                else
                {
                    var rightSec = rightSecOpt;

                    right.Remove(rightSec);
                    var diff =
                        _openApiDiff.SecurityRequirementDiff
                        .Diff(leftSecurity, rightSec, context);
                    if (diff != null)
                    {
                        changedSecurityRequirements.Changed.Add(diff);
                    }
                }
            }

            changedSecurityRequirements.Increased.AddRange(right);

            return(ChangedUtils.IsChanged(changedSecurityRequirements));
        }
Esempio n. 2
0
        public ChangedPathBO Diff(OpenApiPathItem left, OpenApiPathItem right, DiffContextBO context)
        {
            var oldOperationMap = left.Operations;
            var newOperationMap = right.Operations;
            var operationsDiff  =
                MapKeyDiff <OperationType, OpenApiOperation> .Diff(oldOperationMap, newOperationMap);

            var sharedMethods = operationsDiff.SharedKey;
            var changedPath   = new ChangedPathBO(context.URL, left, right, context)
            {
                Increased = operationsDiff.Increased,
                Missing   = operationsDiff.Missing
            };

            foreach (var operationType in sharedMethods)
            {
                var oldOperation = oldOperationMap[operationType];
                var newOperation = newOperationMap[operationType];

                var diff = _openApiDiff
                           .OperationDiff
                           .Diff(oldOperation, newOperation, context.CopyWithMethod(operationType));

                if (diff != null)
                {
                    changedPath.Changed.Add(diff);
                }
            }

            changedPath.Extensions = _openApiDiff
                                     .ExtensionsDiff
                                     .Diff(left.Extensions, right.Extensions, context);

            return(ChangedUtils.IsChanged(changedPath));
        }
Esempio n. 3
0
        public ChangedAPIResponseBO Diff(OpenApiResponses left, OpenApiResponses right, DiffContextBO context)
        {
            var responseMapKeyDiff = MapKeyDiff <string, OpenApiResponse> .Diff(left, right);

            var sharedResponseCodes = responseMapKeyDiff.SharedKey;
            var responses           = new Dictionary <string, ChangedResponseBO>();

            foreach (var responseCode in sharedResponseCodes)
            {
                var diff = _openApiDiff
                           .ResponseDiff
                           .Diff(left[responseCode], right[responseCode], context);

                if (diff != null)
                {
                    responses.Add(responseCode, diff);
                }
            }

            var changedApiResponse =
                new ChangedAPIResponseBO(left, right, context)
            {
                Increased  = responseMapKeyDiff.Increased,
                Missing    = responseMapKeyDiff.Missing,
                Changed    = responses,
                Extensions = _openApiDiff
                             .ExtensionsDiff
                             .Diff(left.Extensions, right.Extensions, context)
            };

            return(ChangedUtils.IsChanged(changedApiResponse));
        }
        private void CompareAdditionalProperties(OpenApiSchema leftSchema,
                                                 OpenApiSchema rightSchema, DiffContextBO context)
        {
            var left  = leftSchema.AdditionalProperties;
            var right = rightSchema.AdditionalProperties;

            if (left != null || right != null)
            {
                var apChangedSchema = new ChangedSchemaBO
                {
                    Context   = context,
                    OldSchema = left,
                    NewSchema = right
                };
                if (left != null && right != null)
                {
                    var addPropChangedSchemaOp =
                        OpenApiDiff
                        .SchemaDiff
                        .Diff(left, right, context.CopyWithRequired(false));
                    apChangedSchema = addPropChangedSchemaOp ?? apChangedSchema;
                }

                var changed = ChangedUtils.IsChanged(apChangedSchema);
                if (changed != null)
                {
                    ChangedSchema.AddProp = changed;
                }
            }
        }
Esempio n. 5
0
        public ChangedOAuthFlowsBO Diff(OpenApiOAuthFlows left, OpenApiOAuthFlows right)
        {
            var changedOAuthFlows = new ChangedOAuthFlowsBO(left, right);

            if (left != null && right != null)
            {
                changedOAuthFlows.ImplicitOAuthFlow = _openApiDiff
                                                      .OAuthFlowDiff
                                                      .Diff(left.Implicit, right.Implicit);
                changedOAuthFlows.PasswordOAuthFlow = _openApiDiff
                                                      .OAuthFlowDiff
                                                      .Diff(left.Password, right.Password);
                changedOAuthFlows.ClientCredentialOAuthFlow = _openApiDiff
                                                              .OAuthFlowDiff
                                                              .Diff(left.ClientCredentials, right.ClientCredentials);
                changedOAuthFlows.AuthorizationCodeOAuthFlow = _openApiDiff
                                                               .OAuthFlowDiff
                                                               .Diff(left.AuthorizationCode, right.AuthorizationCode);
            }

            changedOAuthFlows.Extensions = _openApiDiff
                                           .ExtensionsDiff
                                           .Diff(left?.Extensions, right?.Extensions);

            return(ChangedUtils.IsChanged(changedOAuthFlows));
        }
Esempio n. 6
0
        public ChangedHeadersBO Diff(IDictionary <string, OpenApiHeader> left, IDictionary <string, OpenApiHeader> right,
                                     DiffContextBO context)
        {
            var headerMapDiff = MapKeyDiff <string, OpenApiHeader> .Diff(left, right);

            var sharedHeaderKeys = headerMapDiff.SharedKey;

            var changed = new Dictionary <string, ChangedHeaderBO>();

            foreach (var headerKey in sharedHeaderKeys)
            {
                var oldHeader      = left[headerKey];
                var newHeader      = right[headerKey];
                var changedHeaders = _openApiDiff
                                     .HeaderDiff
                                     .Diff(oldHeader, newHeader, context);
                if (changedHeaders != null)
                {
                    changed.Add(headerKey, changedHeaders);
                }
            }

            return(ChangedUtils.IsChanged(
                       new ChangedHeadersBO(left, right, context)
            {
                Increased = headerMapDiff.Increased,
                Missing = headerMapDiff.Missing,
                Changed = changed
            }));
        }
Esempio n. 7
0
        protected override ChangedHeaderBO ComputeDiff(OpenApiHeader left, OpenApiHeader right,
                                                       DiffContextBO context)
        {
            left  = RefPointer.ResolveRef(_leftComponents, left, left.Reference?.ReferenceV3);
            right = RefPointer.ResolveRef(_rightComponents, right, right.Reference?.ReferenceV3);

            var changedHeader =
                new ChangedHeaderBO(left, right, context)
            {
                Required    = GetBooleanDiff(left.Required, right.Required),
                Deprecated  = !left.Deprecated && right.Deprecated,
                Style       = left.Style != right.Style,
                Explode     = GetBooleanDiff(left.Explode, right.Explode),
                Description = _openApiDiff
                              .MetadataDiff
                              .Diff(left.Description, right.Description, context),
                Schema = _openApiDiff
                         .SchemaDiff
                         .Diff(left.Schema, right.Schema, context.CopyWithRequired(true)),
                Content = _openApiDiff
                          .ContentDiff
                          .Diff(left.Content, right.Content, context),
                Extensions = _openApiDiff
                             .ExtensionsDiff
                             .Diff(left.Extensions, right.Extensions, context)
            };

            return(ChangedUtils.IsChanged(changedHeader));
        }
Esempio n. 8
0
        protected override ChangedRequestBodyBO ComputeDiff(OpenApiRequestBody left,
                                                            OpenApiRequestBody right,
                                                            DiffContextBO context)
        {
            Dictionary <string, OpenApiMediaType> oldRequestContent = null;
            Dictionary <string, OpenApiMediaType> newRequestContent = null;
            OpenApiRequestBody oldRequestBody = null;
            OpenApiRequestBody newRequestBody = null;

            if (left != null)
            {
                oldRequestBody =
                    RefPointer.ResolveRef(
                        _openApiDiff.OldSpecOpenApi.Components, left, left.Reference?.ReferenceV3);
                if (oldRequestBody.Content != null)
                {
                    oldRequestContent = (Dictionary <string, OpenApiMediaType>)oldRequestBody.Content;
                }
            }

            if (right != null)
            {
                newRequestBody =
                    RefPointer.ResolveRef(
                        _openApiDiff.NewSpecOpenApi.Components, right, right.Reference?.ReferenceV3);
                if (newRequestBody.Content != null)
                {
                    newRequestContent = (Dictionary <string, OpenApiMediaType>)newRequestBody.Content;
                }
            }

            var leftRequired =
                oldRequestBody != null && oldRequestBody.Required;
            var rightRequired =
                newRequestBody != null && newRequestBody.Required;

            var changedRequestBody =
                new ChangedRequestBodyBO(oldRequestBody, newRequestBody, context)
            {
                ChangeRequired = leftRequired != rightRequired,
                Description    = _openApiDiff
                                 .MetadataDiff
                                 .Diff(
                    oldRequestBody?.Description,
                    newRequestBody?.Description,
                    context),
                Content = _openApiDiff
                          .ContentDiff
                          .Diff(oldRequestContent, newRequestContent, context),
                Extensions = _openApiDiff
                             .ExtensionsDiff
                             .Diff(GetExtensions(left), GetExtensions(right), context)
            };

            return(ChangedUtils.IsChanged(changedRequestBody));
        }
Esempio n. 9
0
        public ChangedPathsBO Diff(Dictionary <string, OpenApiPathItem> left, Dictionary <string, OpenApiPathItem> right)
        {
            var changedPaths = new ChangedPathsBO(left, right);

            foreach (var(key, value) in right)
            {
                changedPaths.Increased.Add(key, value);
            }

            foreach (var(key, value) in left)
            {
                var template = key.NormalizePath();
                var result   = right.Keys.FirstOrDefault(x => x.NormalizePath() == template);

                if (result != null)
                {
                    if (!changedPaths.Increased.ContainsKey(result))
                    {
                        throw new ArgumentException($"Two path items have the same signature: {template}");
                    }
                    var rightPath = changedPaths.Increased[result];
                    changedPaths.Increased.Remove(result);
                    var paramsDict = new Dictionary <string, string>();
                    if (key != result)
                    {
                        var oldParams = key.ExtractParametersFromPath();
                        var newParams = result.ExtractParametersFromPath();
                        for (var i = oldParams.Count - 1; i >= 0; i--)
                        {
                            paramsDict.Add(oldParams[i], newParams[i]);
                        }
                    }

                    var context = new DiffContextBO
                    {
                        URL        = key,
                        Parameters = paramsDict
                    };

                    var diff = _openApiDiff
                               .PathDiff
                               .Diff(value, rightPath, context);

                    if (diff != null)
                    {
                        changedPaths.Changed.Add(result, diff);
                    }
                }
                else
                {
                    changedPaths.Missing.Add(key, value);
                }
            }

            return(ChangedUtils.IsChanged(changedPaths));
        }
Esempio n. 10
0
 protected ChangedSchemaBO IsApplicable(DiffContextBO context)
 {
     if (ChangedSchema.ReadOnly.IsUnchanged() &&
         ChangedSchema.WriteOnly.IsUnchanged() &&
         !IsPropertyApplicable(ChangedSchema.NewSchema, context))
     {
         return(null);
     }
     return(ChangedUtils.IsChanged(ChangedSchema));
 }
Esempio n. 11
0
        public ChangedOAuthFlowBO Diff(OpenApiOAuthFlow left, OpenApiOAuthFlow right)
        {
            var changedOAuthFlow = new ChangedOAuthFlowBO(left, right);

            if (left != null && right != null)
            {
                changedOAuthFlow.ChangedAuthorizationUrl = left.AuthorizationUrl != right.AuthorizationUrl;
                changedOAuthFlow.ChangedTokenUrl         = left.TokenUrl != right.TokenUrl;
                changedOAuthFlow.ChangedRefreshUrl       = left.RefreshUrl != right.RefreshUrl;
            }

            changedOAuthFlow.Extensions = _openApiDiff
                                          .ExtensionsDiff
                                          .Diff(left?.Extensions, right?.Extensions);

            return(ChangedUtils.IsChanged(changedOAuthFlow));
        }
        public ChangedSecurityRequirementBO Diff(
            OpenApiSecurityRequirement left, OpenApiSecurityRequirement right, DiffContextBO context)
        {
            var changedSecurityRequirement =
                new ChangedSecurityRequirementBO(left, right != null ? GetCopy(right) : null);

            left ??= new OpenApiSecurityRequirement();
            right ??= new OpenApiSecurityRequirement();

            foreach (var(key, value) in left)
            {
                var rightSec = Contains(right, key.Reference?.ReferenceV3);
                if (rightSec.IsNullOrEmpty())
                {
                    changedSecurityRequirement.Missing.Add(key, value);
                }
                else
                {
                    var rightSchemeRef = rightSec.Keys.First();
                    right.Remove(rightSchemeRef);
                    var diff =
                        _openApiDiff
                        .SecuritySchemeDiff
                        .Diff(
                            key.Reference?.ReferenceV3,
                            value.ToList(),
                            rightSchemeRef.Reference?.ReferenceV3,
                            rightSec[rightSchemeRef].ToList(),
                            context);
                    if (diff != null)
                    {
                        changedSecurityRequirement.Changed.Add(diff);
                    }
                }
            }

            foreach (var(key, value) in right)
            {
                changedSecurityRequirement.Increased.Add(key, value);
            }

            return(ChangedUtils.IsChanged(changedSecurityRequirement));
        }
Esempio n. 13
0
        public ChangedParametersBO Diff(
            List <OpenApiParameter> left, List <OpenApiParameter> right, DiffContextBO context)
        {
            var changedParameters =
                new ChangedParametersBO(left, right, context);

            if (null == left)
            {
                left = new List <OpenApiParameter>();
            }
            if (null == right)
            {
                right = new List <OpenApiParameter>();
            }

            foreach (var openApiParameter in left)
            {
                var leftPara = openApiParameter;
                leftPara = RefPointer.ResolveRef(_leftComponents, leftPara, leftPara.Reference?.ReferenceV3);

                var rightParam = Contains(_rightComponents, right, leftPara);
                if (rightParam == null)
                {
                    changedParameters.Missing.Add(leftPara);
                }
                else
                {
                    right.Remove(rightParam);

                    var diff = _openApiDiff.ParameterDiff
                               .Diff(leftPara, rightParam, context);
                    if (diff != null)
                    {
                        changedParameters.Changed.Add(diff);
                    }
                }
            }

            changedParameters.Increased.AddRange(right);

            return(ChangedUtils.IsChanged(changedParameters));
        }
Esempio n. 14
0
        public ChangedContentBO Diff(IDictionary <string, OpenApiMediaType> left,
                                     IDictionary <string, OpenApiMediaType> right, DiffContextBO context)
        {
            var leftDict  = (Dictionary <string, OpenApiMediaType>)left;
            var rightDict = (Dictionary <string, OpenApiMediaType>)right;


            var mediaTypeDiff = MapKeyDiff <string, OpenApiMediaType> .Diff(leftDict, rightDict);

            var sharedMediaTypes  = mediaTypeDiff.SharedKey;
            var changedMediaTypes = new Dictionary <string, ChangedMediaTypeBO>();

            foreach (var sharedMediaType in sharedMediaTypes)
            {
                var oldMediaType     = left[sharedMediaType];
                var newMediaType     = right[sharedMediaType];
                var changedMediaType =
                    new ChangedMediaTypeBO(oldMediaType?.Schema, newMediaType?.Schema, context)
                {
                    Schema = _openApiDiff
                             .SchemaDiff
                             .Diff(
                        oldMediaType?.Schema,
                        newMediaType?.Schema,
                        context.CopyWithRequired(true))
                };
                if (!ChangedUtils.IsUnchanged(changedMediaType))
                {
                    changedMediaTypes.Add(sharedMediaType, changedMediaType);
                }
            }

            return(ChangedUtils.IsChanged(new ChangedContentBO(leftDict, rightDict, context)
            {
                Increased = mediaTypeDiff.Increased,
                Missing = mediaTypeDiff.Missing,
                Changed = changedMediaTypes
            }));
        }
        public ChangedSecuritySchemeBO Diff(
            string leftSchemeRef,
            List <string> leftScopes,
            string rightSchemeRef,
            List <string> rightScopes,
            DiffContextBO context)
        {
            var leftSecurityScheme       = _leftComponents.SecuritySchemes[leftSchemeRef];
            var rightSecurityScheme      = _rightComponents.SecuritySchemes[rightSchemeRef];
            var changedSecuritySchemeOpt =
                CachedDiff(
                    leftSecurityScheme,
                    rightSecurityScheme,
                    leftSchemeRef,
                    rightSchemeRef,
                    context);
            var changedSecurityScheme =
                changedSecuritySchemeOpt ?? new ChangedSecuritySchemeBO(leftSecurityScheme, rightSecurityScheme);

            changedSecurityScheme = GetCopyWithoutScopes(changedSecurityScheme);

            if (changedSecurityScheme != null &&
                leftSecurityScheme.Type == SecuritySchemeType.OAuth2)
            {
                var changed = ChangedUtils.IsChanged(ListDiff.Diff(
                                                         new ChangedSecuritySchemeScopesBO(leftScopes, rightScopes)
                                                         ));

                if (changed != null)
                {
                    changedSecurityScheme.ChangedScopes = changed;
                }
            }

            return(ChangedUtils.IsChanged(changedSecurityScheme));
        }
Esempio n. 16
0
        protected override ChangedResponseBO ComputeDiff(OpenApiResponse left,
                                                         OpenApiResponse right, DiffContextBO context)
        {
            left  = RefPointer.ResolveRef(_leftComponents, left, left.Reference?.ReferenceV3);
            right = RefPointer.ResolveRef(_rightComponents, right, right.Reference?.ReferenceV3);

            var changedResponse = new ChangedResponseBO(left, right, context)
            {
                Description = _openApiDiff
                              .MetadataDiff
                              .Diff(left.Description, right.Description, context),
                Content = _openApiDiff
                          .ContentDiff
                          .Diff(left.Content, right.Content, context),
                Headers = _openApiDiff
                          .HeadersDiff
                          .Diff(left.Headers, right.Headers, context),
                Extensions = _openApiDiff
                             .ExtensionsDiff
                             .Diff(left.Extensions, right.Extensions, context)
            };

            return(ChangedUtils.IsChanged(changedResponse));
        }
Esempio n. 17
0
 public ChangedMetadataBO Diff(string left, string right, DiffContextBO context)
 {
     return(ChangedUtils.IsChanged(new ChangedMetadataBO(left, right)));
 }
Esempio n. 18
0
        public ChangedOperationBO Diff(
            OpenApiOperation oldOperation, OpenApiOperation newOperation, DiffContextBO context)
        {
            var changedOperation =
                new ChangedOperationBO(context.URL, context.Method, oldOperation, newOperation)
            {
                Summary = _openApiDiff
                          .MetadataDiff
                          .Diff(oldOperation.Summary, newOperation.Summary, context),
                Description = _openApiDiff
                              .MetadataDiff
                              .Diff(oldOperation.Description, newOperation.Description, context),
                IsDeprecated = !oldOperation.Deprecated && newOperation.Deprecated
            };

            if (oldOperation.RequestBody != null || newOperation.RequestBody != null)
            {
                changedOperation.RequestBody = _openApiDiff
                                               .RequestBodyDiff
                                               .Diff(
                    oldOperation.RequestBody, newOperation.RequestBody, context.CopyAsRequest());
            }

            var parametersDiff = _openApiDiff
                                 .ParametersDiff
                                 .Diff(oldOperation.Parameters.ToList(), newOperation.Parameters.ToList(), context);

            if (parametersDiff != null)
            {
                RemovePathParameters(context.Parameters, parametersDiff);
                changedOperation.Parameters = parametersDiff;
            }


            if (oldOperation.Responses != null || newOperation.Responses != null)
            {
                var diff = _openApiDiff
                           .APIResponseDiff
                           .Diff(oldOperation.Responses, newOperation.Responses, context.CopyAsResponse());

                if (diff != null)
                {
                    changedOperation.APIResponses = diff;
                }
            }

            if (oldOperation.Security != null || newOperation.Security != null)
            {
                var diff = _openApiDiff
                           .SecurityRequirementsDiff
                           .Diff(oldOperation.Security, newOperation.Security, context);

                if (diff != null)
                {
                    changedOperation.SecurityRequirements = diff;
                }
            }

            changedOperation.Extensions =
                _openApiDiff
                .ExtensionsDiff
                .Diff(oldOperation.Extensions, newOperation.Extensions, context);

            return(ChangedUtils.IsChanged(changedOperation));
        }