Add some additional tests

Author: stevejgordon

test/OpenTelemetry.Configuration.Declarative.Tests/ConfigPropertyTests.cs

@@ -0,0 +1,72 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma warning disable OTEL1006
+
+namespace OpenTelemetry.Configuration.Declarative.Tests;
+
+public sealed class ConfigPropertyTests
+{
+    [Fact]
+    public void IsAbsent_WhenAbsent_ReturnsTrue() =>
+        Assert.True(ConfigProperty<string>.Absent.IsAbsent);
+
+    [Fact]
+    public void IsAbsent_WhenNull_ReturnsFalse() =>
+        Assert.False(ConfigProperty<string>.Null.IsAbsent);
+
+    [Fact]
+    public void IsAbsent_WhenPresent_ReturnsFalse() =>
+        Assert.False(ConfigProperty<string>.Create("x").IsAbsent);
+
+    [Fact]
+    public void IsNull_WhenNull_ReturnsTrue() =>
+        Assert.True(ConfigProperty<string>.Null.IsNull);
+
+    [Fact]
+    public void IsNull_WhenAbsent_ReturnsFalse() =>
+        Assert.False(ConfigProperty<string>.Absent.IsNull);
+
+    [Fact]
+    public void IsNull_WhenPresent_ReturnsFalse() =>
+        Assert.False(ConfigProperty<string>.Create("x").IsNull);
+
+    [Fact]
+    public void Value_WhenPresent_ReturnsValue() =>
+        Assert.Equal("hello", ConfigProperty<string>.Create("hello").Value);
+
+    [Fact]
+    public void Value_WhenAbsent_ThrowsInvalidOperationException() =>
+        Assert.Throws<InvalidOperationException>(() => ConfigProperty<string>.Absent.Value);
+
+    [Fact]
+    public void Value_WhenNull_ThrowsInvalidOperationException() =>
+        Assert.Throws<InvalidOperationException>(() => ConfigProperty<string>.Null.Value);
+
+    [Fact]
+    public void Deconstruct_WhenPresent_YieldsStateAndValue()
+    {
+        var (state, value) = ConfigProperty<string>.Create("hello");
+
+        Assert.Equal(ConfigPropertyState.Present, state);
+        Assert.Equal("hello", value);
+    }
+
+    [Fact]
+    public void Deconstruct_WhenAbsent_YieldsStateAndDefault()
+    {
+        var (state, value) = ConfigProperty<string>.Absent;
+
+        Assert.Equal(ConfigPropertyState.Absent, state);
+        Assert.Null(value);
+    }
+
+    [Fact]
+    public void Deconstruct_WhenNull_YieldsStateAndDefault()
+    {
+        var (state, value) = ConfigProperty<string>.Null;
+
+        Assert.Equal(ConfigPropertyState.Null, state);
+        Assert.Null(value);
+    }
+}

test/OpenTelemetry.Configuration.Declarative.Tests/DeclarativeConfigurationEventSourceTests.cs

@@ -8,6 +8,7 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics.Tracing;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Tests;
 
 namespace OpenTelemetry.Configuration.Declarative.Tests;
@@ -208,6 +209,28 @@ public void ReadConfiguration_ResourceAttributeNullValue_EmitsNullValueWarning()
         Assert.DoesNotContain("missing", message, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Fact]
+    public void ReadConfiguration_ResourceAttributeAbsentValue_EmitsMissingValueWarning()
+    {
+        // No 'value' key at all: distinct from value: ~ (NullScalar) and value: {mapping}.
+        // The warning must say "missing", not "null" or "mapping".
+        const string yaml = """
+            file_format: "1.0"
+            resource:
+              attributes:
+                - name: my.attr
+            """;
+
+        using var listener = CreateWarningListener();
+
+        _ = ReadConfiguration(yaml);
+
+        var warning = Assert.Single(listener.Messages, e => e.EventId == 3);
+        var message = warning.Payload![0] as string;
+        Assert.Contains("missing", message, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("null", message, StringComparison.OrdinalIgnoreCase);
+    }
+
     [Theory]
     [InlineData("bool", "yes")]
     [InlineData("bool", "no")]
@@ -387,6 +410,26 @@ public void AddOpenTelemetryDeclarativeConfiguration_Parameterless_NoEnvVar_Emit
         Assert.Single(listener.Messages, e => e.EventId == 17);
     }
 
+    [Fact]
+    public void UseDeclarativeConfiguration_FactoryDescriptorReturnsNull_EmitsPriorConfigurationResolutionFailedWarning()
+    {
+        // Register an IConfiguration factory that returns null to exercise the path where
+        // a descriptor was found but resolves to null at runtime (Event 19).
+        using var yamlFile = DeclarativeYamlTestFile.CreateDeclarativeYaml(disabled: true);
+
+        var services = new ServiceCollection();
+        services.AddSingleton<IConfiguration>(_ => null!);
+
+        new TestEventSourceBuilder(services).UseDeclarativeConfiguration(yamlFile.Path);
+
+        using var listener = CreateWarningListener();
+
+        var config = services.BuildServiceProvider().GetRequiredService<IConfiguration>();
+
+        Assert.Single(listener.Messages, e => e.EventId == 19);
+        Assert.Equal("true", config[OtelEnvironmentVariables.SdkDisabled]);
+    }
+
     private static TestEventListener CreateVerboseListener()
     {
         var listener = new TestEventListener();
@@ -412,4 +455,14 @@ private static TestEventListener CreateWarningListener()
         using var factory = new DeclarativeYamlTestFileFactory();
         return DeclarativeConfigurationReader.Read(new FilePath(factory.CreateYamlFile(yaml)));
     }
+
+    private sealed class TestEventSourceBuilder : IOpenTelemetryBuilder
+    {
+        public TestEventSourceBuilder(IServiceCollection services)
+        {
+            this.Services = services;
+        }
+
+        public IServiceCollection Services { get; }
+    }
 }

test/OpenTelemetry.Configuration.Declarative.Tests/DeclarativeConfigurationFilePathTests.cs

@@ -82,6 +82,48 @@ public void ToString_ReturnsOriginalPath()
         Assert.Equal(path, new FilePath(path).ToString());
     }
 
+    [Fact]
+    public void GetHashCode_EqualFilePaths_SameHashCode()
+    {
+        using var factory = new DeclarativeYamlTestFileFactory();
+        var absolutePath = factory.CreateDeclarativeYaml(disabled: true);
+        var originalDirectory = Directory.GetCurrentDirectory();
+
+        try
+        {
+            Directory.SetCurrentDirectory(factory.TempDirectory);
+            var relativePath = Path.GetFileName(absolutePath);
+
+            var a = new FilePath(absolutePath);
+            var b = new FilePath(relativePath);
+
+            Assert.Equal(a, b);
+            Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        }
+        finally
+        {
+            Directory.SetCurrentDirectory(originalDirectory);
+        }
+    }
+
+    [Fact]
+    public void GetHashCode_DifferentPathCasingOnWindows_SameHashCode()
+    {
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            return;
+        }
+
+        using var factory = new DeclarativeYamlTestFileFactory();
+        var absolutePath = factory.CreateDeclarativeYaml(disabled: true);
+
+        var a = new FilePath(absolutePath);
+        var b = new FilePath(absolutePath.ToUpperInvariant());
+
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+    }
+
     [Fact]
     public void Path_RelativeInput_IsAbsolute()
     {

test/OpenTelemetry.Configuration.Declarative.Tests/DeclarativeConfigurationReaderTests.cs

@@ -95,6 +95,22 @@ public void Translate_EmptyYaml_ProducesNoKeys()
         Assert.Empty(data);
     }
 
+    [Fact]
+    public void Translate_NonScalarTopLevelKey_IsIgnoredWithoutThrowing()
+    {
+        // YAML supports non-scalar (e.g. sequence) keys via the explicit '? ...' syntax.
+        // Such a key can never be a valid OTel section name; it must be skipped without throwing.
+        const string yaml = """
+            file_format: "1.0"
+            ? [a, b]
+            : some_value
+            """;
+
+        var data = ReadConfiguration(yaml);
+
+        Assert.Empty(data);
+    }
+
     [Fact]
     public void Translate_UnknownTopLevelSection_IsIgnoredWithoutThrowing()
     {
@@ -737,6 +753,43 @@ public void Translate_ResourceAttributeNullValue_IsSkipped(string nullValue)
         Assert.Equal("service.name=my-service", data[DeclarativeConfigurationConverter.ResourceAttributesKey]);
     }
 
+    [Fact]
+    public void Translate_ResourceAttributeMissingValue_IsSkipped()
+    {
+        // The absent-value entry is skipped; a valid sibling must still be emitted.
+        const string yaml = """
+            file_format: "1.0"
+            resource:
+              attributes:
+                - name: my.attr
+                - name: service.name
+                  value: my-service
+            """;
+
+        var data = ReadConfiguration(yaml);
+
+        Assert.Equal("service.name=my-service", data[DeclarativeConfigurationConverter.ResourceAttributesKey]);
+    }
+
+    [Fact]
+    public void Translate_ResourceAttributeNonMappingSequenceItem_IsSkipped()
+    {
+        // A sequence item that is a scalar (not a mapping) cannot be parsed as an attribute
+        // entry and is skipped; a valid sibling must still be emitted.
+        const string yaml = """
+            file_format: "1.0"
+            resource:
+              attributes:
+                - not-a-mapping
+                - name: service.name
+                  value: my-service
+            """;
+
+        var data = ReadConfiguration(yaml);
+
+        Assert.Equal("service.name=my-service", data[DeclarativeConfigurationConverter.ResourceAttributesKey]);
+    }
+
     [Theory]
     [InlineData("~")]
     [InlineData("null")]

test/OpenTelemetry.Configuration.Declarative.Tests/YamlNodeReaderTests.cs

@@ -0,0 +1,18 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma warning disable OTEL1006
+
+using YamlDotNet.RepresentationModel;
+
+namespace OpenTelemetry.Configuration.Declarative.Tests;
+
+public sealed class YamlNodeReaderTests
+{
+    [Fact]
+    public void GetScalarString_NullScalarValue_ReturnsNull()
+    {
+        var scalar = new YamlScalarNode((string?)null);
+        Assert.Null(scalar.GetScalarString());
+    }
+}