test(coverage): add reference and reader edge tests

Add focused tests for CopyReferences, OpenApiSecurityRequirement deserialization, and small uncovered exception/helper types without broad fixture duplication.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: baywet

test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiSecurityRequirementTests.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json.Nodes;
+using Microsoft.OpenApi.Reader;
+using Microsoft.OpenApi.Reader.V2;
+using Microsoft.OpenApi.YamlReader;
+using SharpYaml.Serialization;
+using Xunit;
+
+namespace Microsoft.OpenApi.Readers.Tests.V2Tests;
+
+[Collection("DefaultSettings")]
+public class OpenApiSecurityRequirementTests
+{
+    [Fact]
+    public void LoadSecurityRequirementResolvesScopesForKnownSchemes()
+    {
+        var node = LoadYamlNode(
+            """
+            petstore_auth:
+              - write:pets
+              - read:pets
+            """);
+        var hostDocument = new OpenApiDocument
+        {
+            Components = new OpenApiComponents
+            {
+                SecuritySchemes = new Dictionary<string, IOpenApiSecurityScheme>
+                {
+                    ["petstore_auth"] = new OpenApiSecurityScheme { Type = SecuritySchemeType.OAuth2 }
+                }
+            }
+        };
+        var context = new ParsingContext(new OpenApiDiagnostic());
+
+        var requirement = OpenApiV2Deserializer.LoadSecurityRequirement(node, hostDocument, context);
+
+        var resolvedScheme = Assert.Single(requirement);
+        Assert.Equal("petstore_auth", resolvedScheme.Key.Reference.Id);
+        Assert.Equal(["write:pets", "read:pets"], resolvedScheme.Value);
+        Assert.Empty(context.Diagnostic.Errors);
+    }
+
+    [Fact]
+    public void LoadSecurityRequirementCreatesUnresolvedReferenceWhenSchemeIsMissing()
+    {
+        var node = LoadYamlNode(
+            """
+            petstore_auth:
+              - write:pets
+            """);
+        var hostDocument = new OpenApiDocument();
+        var context = new ParsingContext(new OpenApiDiagnostic());
+
+        var requirement = OpenApiV2Deserializer.LoadSecurityRequirement(node, hostDocument, context);
+
+        var unresolvedScheme = Assert.Single(requirement);
+        Assert.Equal("petstore_auth", unresolvedScheme.Key.Reference.Id);
+        Assert.True(unresolvedScheme.Key.UnresolvedReference);
+        Assert.Equal(["write:pets"], unresolvedScheme.Value);
+        Assert.Empty(context.Diagnostic.Errors);
+    }
+
+    private static JsonNode LoadYamlNode(string yaml)
+    {
+        using var reader = new StringReader(yaml);
+        var yamlStream = new YamlStream();
+        yamlStream.Load(reader);
+        return yamlStream.Documents[0].RootNode.ToJsonNode();
+    }
+}

test/Microsoft.OpenApi.Tests/Exceptions/OpenApiWriterExceptionTests.cs

@@ -0,0 +1,27 @@
+using System;
+using Xunit;
+
+namespace Microsoft.OpenApi.Tests.Exceptions;
+
+public class OpenApiWriterExceptionTests
+{
+    [Fact]
+    public void DefaultConstructorUsesTheGenericWriterMessage()
+    {
+        var exception = new OpenApiWriterException();
+
+        Assert.Equal(SRResource.OpenApiWriterExceptionGenericError, exception.Message);
+        Assert.Null(exception.InnerException);
+    }
+
+    [Fact]
+    public void ConstructorPreservesMessageAndInnerException()
+    {
+        var innerException = new InvalidOperationException("boom");
+
+        var exception = new OpenApiWriterException("writer failed", innerException);
+
+        Assert.Equal("writer failed", exception.Message);
+        Assert.Same(innerException, exception.InnerException);
+    }
+}

test/Microsoft.OpenApi.Tests/Models/OpenApiReferenceErrorTests.cs

@@ -0,0 +1,37 @@
+using Xunit;
+
+namespace Microsoft.OpenApi.Tests.Models;
+
+public class OpenApiReferenceErrorTests
+{
+    [Fact]
+    public void ConstructorCopiesMessageAndPointerFromException()
+    {
+        var exception = new OpenApiException("Reference could not be resolved")
+        {
+            Pointer = "#/components/schemas/Pet"
+        };
+
+        var error = new OpenApiReferenceError(exception);
+
+        Assert.Equal(exception.Message, error.Message);
+        Assert.Equal(exception.Pointer, error.Pointer);
+        Assert.Null(error.Reference);
+    }
+
+    [Fact]
+    public void ConstructorStoresTheReferenceThatFailedResolution()
+    {
+        var reference = new BaseOpenApiReference
+        {
+            Id = "Pet",
+            Type = ReferenceType.Schema
+        };
+
+        var error = new OpenApiReferenceError(reference, "Missing component");
+
+        Assert.Equal("Missing component", error.Message);
+        Assert.Equal(string.Empty, error.Pointer);
+        Assert.Same(reference, error.Reference);
+    }
+}

test/Microsoft.OpenApi.Tests/Reader/AnyListFieldMapParameterTests.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Text.Json.Nodes;
+using Xunit;
+using Microsoft.OpenApi.Reader;
+
+namespace Microsoft.OpenApi.Tests.Reader;
+
+public class AnyListFieldMapParameterTests
+{
+    [Fact]
+    public void ConstructorStoresPropertyDelegates()
+    {
+        var schema = new OpenApiSchema { Type = JsonSchemaType.Array };
+        var values = new List<JsonNode> { JsonValue.Create("value")! };
+        var owner = new TestOwner { Schema = schema };
+        var parameter = new AnyListFieldMapParameter<TestOwner>(
+            static current => current.Values,
+            static (current, currentValues) => current.Values = currentValues,
+            static current => current.Schema);
+
+        parameter.PropertySetter(owner, values);
+
+        Assert.Same(values, parameter.PropertyGetter(owner));
+        Assert.NotNull(parameter.SchemaGetter);
+        Assert.Same(schema, parameter.SchemaGetter(owner));
+    }
+
+    private sealed class TestOwner
+    {
+        public List<JsonNode> Values { get; set; } = [];
+        public OpenApiSchema Schema { get; set; } = new();
+    }
+}

test/Microsoft.OpenApi.Tests/Services/CopyReferencesTests.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using Xunit;
+
+namespace Microsoft.OpenApi.Tests.Services;
+
+public class CopyReferencesTests
+{
+    [Fact]
+    public void VisitCopiesResolvedReferenceTargetsIntoMatchingComponentCollections()
+    {
+        var callback = new OpenApiCallback
+        {
+            PathItems = new Dictionary<RuntimeExpression, IOpenApiPathItem>
+            {
+                [RuntimeExpression.Build("{$request.body#/callbackUrl}")] = new OpenApiPathItem
+                {
+                    Operations = new Dictionary<HttpMethod, OpenApiOperation>
+                    {
+                        [HttpMethod.Post] = new()
+                        {
+                            Responses = new OpenApiResponses
+                            {
+                                ["200"] = new OpenApiResponse { Description = "ok" }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        var link = new OpenApiLink { OperationId = "getUser" };
+        var requestBody = new OpenApiRequestBody
+        {
+            Required = true,
+            Content = new Dictionary<string, IOpenApiMediaType>
+            {
+                ["application/json"] = new OpenApiMediaType()
+            }
+        };
+        var securityScheme = new OpenApiSecurityScheme
+        {
+            Type = SecuritySchemeType.ApiKey,
+            Name = "api-key",
+            In = ParameterLocation.Header
+        };
+
+        var source = new OpenApiDocument
+        {
+            Components = new OpenApiComponents
+            {
+                Callbacks = new Dictionary<string, IOpenApiCallback> { ["callback"] = callback },
+                Links = new Dictionary<string, IOpenApiLink> { ["link"] = link },
+                RequestBodies = new Dictionary<string, IOpenApiRequestBody> { ["body"] = requestBody },
+                SecuritySchemes = new Dictionary<string, IOpenApiSecurityScheme> { ["scheme"] = securityScheme }
+            }
+        };
+        source.RegisterComponents();
+        var target = new OpenApiDocument();
+        var visitor = new CopyReferences(target);
+
+        visitor.Visit((IOpenApiReferenceHolder)new OpenApiCallbackReference("callback", source));
+        visitor.Visit((IOpenApiReferenceHolder)new OpenApiLinkReference("link", source));
+        visitor.Visit((IOpenApiReferenceHolder)new OpenApiRequestBodyReference("body", source));
+        visitor.Visit((IOpenApiReferenceHolder)new OpenApiSecuritySchemeReference("scheme", source));
+
+        Assert.Same(callback, Assert.Single(visitor.Components.Callbacks).Value);
+        Assert.Same(link, Assert.Single(visitor.Components.Links).Value);
+        Assert.Same(requestBody, Assert.Single(visitor.Components.RequestBodies).Value);
+        Assert.Same(securityScheme, Assert.Single(visitor.Components.SecuritySchemes).Value);
+
+        Assert.NotNull(target.Components);
+        Assert.NotNull(target.Components.Callbacks);
+        Assert.NotNull(target.Components.Links);
+        Assert.NotNull(target.Components.RequestBodies);
+        Assert.NotNull(target.Components.SecuritySchemes);
+    }
+
+    [Fact]
+    public void VisitCopiesSchemaTargetsOnceAndIgnoresMissingReferences()
+    {
+        var schema = new OpenApiSchema { Type = JsonSchemaType.Object };
+        var source = new OpenApiDocument
+        {
+            Components = new OpenApiComponents
+            {
+                Schemas = new Dictionary<string, IOpenApiSchema> { ["Pet"] = schema }
+            }
+        };
+        source.RegisterComponents();
+        var visitor = new CopyReferences(new OpenApiDocument());
+
+        visitor.Visit((IOpenApiReferenceHolder)new OpenApiLinkReference("missing", source));
+
+        var schemaReference = new OpenApiSchemaReference("Pet", source);
+        visitor.Visit((IOpenApiSchema)schemaReference);
+        visitor.Visit((IOpenApiSchema)schemaReference);
+
+        Assert.Null(visitor.Components.Links);
+        var copiedSchema = Assert.Single(visitor.Components.Schemas);
+        Assert.Equal("Pet", copiedSchema.Key);
+        Assert.Same(schema, copiedSchema.Value);
+    }
+}