357 lines
12 KiB
C#
357 lines
12 KiB
C#
// -----------------------------------------------------------------------------
|
|
// PolicyAnalyzerRoslynTests.cs
|
|
// Sprint: SPRINT_5100_0010_0004_airgap_tests
|
|
// Tasks: AIRGAP-5100-005, AIRGAP-5100-006
|
|
// Description: AN1 Roslyn compilation tests for AirGap.Policy.Analyzers
|
|
// -----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CodeActions;
|
|
using Microsoft.CodeAnalysis.CodeFixes;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
using Microsoft.CodeAnalysis.Diagnostics;
|
|
using Microsoft.CodeAnalysis.Text;
|
|
using Xunit;
|
|
using FluentAssertions;
|
|
|
|
|
|
using StellaOps.TestKit;
|
|
namespace StellaOps.AirGap.Policy.Analyzers.Tests;
|
|
|
|
/// <summary>
|
|
/// AN1 Roslyn Compilation Tests for AirGap.Policy.Analyzers
|
|
/// Task AIRGAP-5100-005: Expected diagnostics, no false positives
|
|
/// Task AIRGAP-5100-006: Golden generated code tests for policy analyzers
|
|
/// </summary>
|
|
public sealed class PolicyAnalyzerRoslynTests
|
|
{
|
|
#region AIRGAP-5100-005: Expected Diagnostics & No False Positives
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Theory]
|
|
[InlineData("var client = new HttpClient();", true, "Direct construction should trigger diagnostic")]
|
|
[InlineData("var client = new System.Net.Http.HttpClient();", true, "Fully qualified construction should trigger diagnostic")]
|
|
[InlineData("HttpClient client = new();", true, "Target-typed new should trigger diagnostic")]
|
|
[InlineData("object client = new HttpClient();", true, "Implicit cast construction should trigger diagnostic")]
|
|
public async Task DiagnosticTriggered_ForVariousHttpClientConstructions(string statement, bool shouldTrigger, string reason)
|
|
{
|
|
var source = $$"""
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
public void Run()
|
|
{
|
|
{{statement}}
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
var hasDiagnostic = diagnostics.Any(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId);
|
|
|
|
hasDiagnostic.Should().Be(shouldTrigger, reason);
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task NoDiagnostic_ForHttpClientParameter()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
public void Run(HttpClient client)
|
|
{
|
|
// Using HttpClient as parameter - not constructing it
|
|
client.GetStringAsync("https://example.com");
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
diagnostics.Should().NotContain(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId,
|
|
"Using HttpClient as parameter should not trigger diagnostic");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task NoDiagnostic_ForHttpClientField()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
private HttpClient? _client;
|
|
|
|
public void SetClient(HttpClient client)
|
|
{
|
|
_client = client;
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
diagnostics.Should().NotContain(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId,
|
|
"Declaring HttpClient field should not trigger diagnostic");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task NoDiagnostic_ForFactoryMethodReturn()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public interface IHttpClientFactory
|
|
{
|
|
HttpClient CreateClient(string name);
|
|
}
|
|
|
|
public sealed class Demo
|
|
{
|
|
private readonly IHttpClientFactory _factory;
|
|
|
|
public Demo(IHttpClientFactory factory) => _factory = factory;
|
|
|
|
public void Run()
|
|
{
|
|
var client = _factory.CreateClient("default");
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
diagnostics.Should().NotContain(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId,
|
|
"Using factory method should not trigger diagnostic");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task NoDiagnostic_InTestAssembly()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App.Tests;
|
|
|
|
public sealed class DemoTests
|
|
{
|
|
public void TestMethod()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App.Tests");
|
|
diagnostics.Should().NotContain(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId,
|
|
"Test assemblies should be exempt from diagnostic");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task NoDiagnostic_InPolicyAssembly()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace StellaOps.AirGap.Policy.Internal;
|
|
|
|
internal static class Loopback
|
|
{
|
|
public static HttpClient Create() => new HttpClient();
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "StellaOps.AirGap.Policy");
|
|
diagnostics.Should().NotContain(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId,
|
|
"Policy assembly itself should be exempt");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task Diagnostic_HasCorrectSeverity()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
public void Run()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
var airgapDiagnostic = diagnostics.Single(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId);
|
|
|
|
airgapDiagnostic.Severity.Should().Be(DiagnosticSeverity.Warning,
|
|
"Diagnostic should be a warning, not an error");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task Diagnostic_HasCorrectLocation()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
public void Run()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
var airgapDiagnostic = diagnostics.Single(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId);
|
|
|
|
airgapDiagnostic.Location.IsInSource.Should().BeTrue();
|
|
var lineSpan = airgapDiagnostic.Location.GetLineSpan();
|
|
lineSpan.StartLinePosition.Line.Should().Be(8, "Diagnostic should point to line 9 (0-indexed: 8)");
|
|
}
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task MultipleHttpClientUsages_ReportMultipleDiagnostics()
|
|
{
|
|
const string source = """
|
|
using System.Net.Http;
|
|
|
|
namespace Sample.App;
|
|
|
|
public sealed class Demo
|
|
{
|
|
public void Method1()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
|
|
public void Method2()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
|
|
public void Method3()
|
|
{
|
|
var client = new HttpClient();
|
|
}
|
|
}
|
|
""";
|
|
|
|
var diagnostics = await AnalyzeAsync(source, assemblyName: "Sample.App");
|
|
var airgapDiagnostics = diagnostics.Where(d => d.Id == HttpClientUsageAnalyzer.DiagnosticId).ToList();
|
|
|
|
airgapDiagnostics.Should().HaveCount(3, "Each new HttpClient() should trigger a separate diagnostic");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AIRGAP-5100-006: Golden Generated Code Tests
|
|
|
|
[Trait("Category", TestCategories.Unit)]
|
|
[Fact]
|
|
public async Task Analyzer_SupportedDiagnostics_ContainsExpectedId()
|
|
{
|
|
var analyzer = new HttpClientUsageAnalyzer();
|
|
var supportedDiagnostics = analyzer.SupportedDiagnostics;
|
|
|
|
supportedDiagnostics.Should().HaveCount(1);
|
|
supportedDiagnostics[0].Id.Should().Be("AIRGAP001");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Test Helpers
|
|
|
|
private static async Task<ImmutableArray<Diagnostic>> AnalyzeAsync(string source, string assemblyName)
|
|
{
|
|
var compilation = CSharpCompilation.Create(
|
|
assemblyName,
|
|
new[]
|
|
{
|
|
CSharpSyntaxTree.ParseText(source),
|
|
CSharpSyntaxTree.ParseText(PolicyStubSource),
|
|
},
|
|
CreateMetadataReferences(),
|
|
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
|
|
|
|
var analyzer = new HttpClientUsageAnalyzer();
|
|
var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer));
|
|
return await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync();
|
|
}
|
|
|
|
private static IEnumerable<MetadataReference> CreateMetadataReferences()
|
|
{
|
|
// Core runtime references
|
|
yield return MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location);
|
|
yield return MetadataReference.CreateFromFile(typeof(Uri).GetTypeInfo().Assembly.Location);
|
|
yield return MetadataReference.CreateFromFile(typeof(HttpClient).GetTypeInfo().Assembly.Location);
|
|
yield return MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location);
|
|
|
|
// Add System.Runtime for target-typed new
|
|
var systemRuntimePath = Path.GetDirectoryName(typeof(object).GetTypeInfo().Assembly.Location);
|
|
if (!string.IsNullOrEmpty(systemRuntimePath))
|
|
{
|
|
var netstandard = Path.Combine(systemRuntimePath, "netstandard.dll");
|
|
if (File.Exists(netstandard))
|
|
{
|
|
yield return MetadataReference.CreateFromFile(netstandard);
|
|
}
|
|
|
|
var systemRuntime = Path.Combine(systemRuntimePath, "System.Runtime.dll");
|
|
if (File.Exists(systemRuntime))
|
|
{
|
|
yield return MetadataReference.CreateFromFile(systemRuntime);
|
|
}
|
|
}
|
|
}
|
|
|
|
private const string PolicyStubSource = """
|
|
namespace StellaOps.AirGap.Policy
|
|
{
|
|
public interface IEgressPolicy
|
|
{
|
|
void EnsureAllowed(EgressRequest request);
|
|
}
|
|
|
|
public readonly record struct EgressRequest(string Component, System.Uri Destination, string Intent);
|
|
|
|
public static class EgressHttpClientFactory
|
|
{
|
|
public static System.Net.Http.HttpClient Create(IEgressPolicy egressPolicy, EgressRequest request)
|
|
=> throw new System.NotImplementedException();
|
|
}
|
|
}
|
|
""";
|
|
|
|
#endregion
|
|
}
|