up

tests/reachability/StellaOps.Reachability.FixtureTests/ReachabilityLifterTests.cs

@@ -0,0 +1,405 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using StellaOps.Scanner.Reachability;
+using StellaOps.Scanner.Reachability.Lifters;
+using Xunit;
+
+namespace StellaOps.Reachability.FixtureTests;
+
+public sealed class ReachabilityLifterTests : IDisposable
+{
+    private readonly string _tempDir;
+
+    public ReachabilityLifterTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), $"lifter-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(_tempDir);
+    }
+
+    public void Dispose()
+    {
+        try
+        {
+            if (Directory.Exists(_tempDir))
+            {
+                Directory.Delete(_tempDir, true);
+            }
+        }
+        catch
+        {
+            // Best effort cleanup
+        }
+    }
+
+    [Fact]
+    public async Task NodeLifter_ExtractsPackageInfo()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "my-app",
+            "version": "1.0.0",
+            "main": "index.js",
+            "dependencies": {
+                "express": "^4.18.0",
+                "lodash": "^4.17.0"
+            }
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var lifter = new NodeReachabilityLifter();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-001"
+        };
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        await lifter.LiftAsync(context, builder, CancellationToken.None);
+        var graph = builder.ToUnionGraph("node");
+
+        // Assert
+        graph.Nodes.Should().NotBeEmpty();
+        graph.Nodes.Should().Contain(n => n.Display == "my-app");
+        graph.Nodes.Should().Contain(n => n.Display == "express");
+        graph.Nodes.Should().Contain(n => n.Display == "lodash");
+
+        graph.Edges.Should().NotBeEmpty();
+        graph.Edges.Should().Contain(e => e.EdgeType == "import");
+    }
+
+    [Fact]
+    public async Task NodeLifter_ExtractsEntrypoints()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "my-cli",
+            "version": "2.0.0",
+            "main": "lib/index.js",
+            "module": "lib/index.mjs",
+            "bin": {
+                "mycli": "bin/cli.js"
+            }
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var lifter = new NodeReachabilityLifter();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-002"
+        };
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        await lifter.LiftAsync(context, builder, CancellationToken.None);
+        var graph = builder.ToUnionGraph("node");
+
+        // Assert
+        graph.Nodes.Should().Contain(n => n.Kind == "entrypoint");
+        graph.Nodes.Should().Contain(n => n.Kind == "binary");
+        graph.Edges.Should().Contain(e => e.EdgeType == "loads");
+        graph.Edges.Should().Contain(e => e.EdgeType == "spawn");
+    }
+
+    [Fact]
+    public async Task NodeLifter_ExtractsImportsFromSource()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "my-app",
+            "version": "1.0.0"
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var sourceCode = """
+        import express from 'express';
+        const lodash = require('lodash');
+        import('./dynamic-module.js');
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "index.js"), sourceCode);
+
+        var lifter = new NodeReachabilityLifter();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-003"
+        };
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        await lifter.LiftAsync(context, builder, CancellationToken.None);
+        var graph = builder.ToUnionGraph("node");
+
+        // Assert
+        graph.Nodes.Should().Contain(n => n.Display == "express");
+        graph.Nodes.Should().Contain(n => n.Display == "lodash");
+        graph.Edges.Count(e => e.EdgeType == "import").Should().BeGreaterOrEqualTo(2);
+    }
+
+    [Fact]
+    public async Task DotNetLifter_ExtractsProjectInfo()
+    {
+        // Arrange
+        var csproj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <TargetFramework>net8.0</TargetFramework>
+            <AssemblyName>MyApp</AssemblyName>
+            <RootNamespace>MyCompany.MyApp</RootNamespace>
+          </PropertyGroup>
+          <ItemGroup>
+            <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+            <PackageReference Include="Serilog" Version="3.1.1" />
+          </ItemGroup>
+        </Project>
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "MyApp.csproj"), csproj);
+
+        var lifter = new DotNetReachabilityLifter();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-004"
+        };
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        await lifter.LiftAsync(context, builder, CancellationToken.None);
+        var graph = builder.ToUnionGraph("dotnet");
+
+        // Assert
+        graph.Nodes.Should().NotBeEmpty();
+        graph.Nodes.Should().Contain(n => n.Display == "MyApp");
+        graph.Nodes.Should().Contain(n => n.Display == "Newtonsoft.Json");
+        graph.Nodes.Should().Contain(n => n.Display == "Serilog");
+        graph.Nodes.Should().Contain(n => n.Kind == "namespace" && n.Display == "MyCompany.MyApp");
+
+        graph.Edges.Should().NotBeEmpty();
+        graph.Edges.Count(e => e.EdgeType == "import").Should().BeGreaterOrEqualTo(2);
+    }
+
+    [Fact]
+    public async Task DotNetLifter_ExtractsProjectReferences()
+    {
+        // Arrange
+        var libDir = Path.Combine(_tempDir, "Lib");
+        Directory.CreateDirectory(libDir);
+
+        var libCsproj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <TargetFramework>net8.0</TargetFramework>
+            <AssemblyName>MyLib</AssemblyName>
+          </PropertyGroup>
+        </Project>
+        """;
+        await File.WriteAllTextAsync(Path.Combine(libDir, "MyLib.csproj"), libCsproj);
+
+        var appCsproj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <TargetFramework>net8.0</TargetFramework>
+            <AssemblyName>MyApp</AssemblyName>
+          </PropertyGroup>
+          <ItemGroup>
+            <ProjectReference Include="Lib/MyLib.csproj" />
+          </ItemGroup>
+        </Project>
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "MyApp.csproj"), appCsproj);
+
+        var lifter = new DotNetReachabilityLifter();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-005"
+        };
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        await lifter.LiftAsync(context, builder, CancellationToken.None);
+        var graph = builder.ToUnionGraph("dotnet");
+
+        // Assert
+        graph.Nodes.Should().Contain(n => n.Display == "MyApp");
+        graph.Nodes.Should().Contain(n => n.Display == "MyLib");
+        graph.Edges.Should().Contain(e => e.EdgeType == "import");
+    }
+
+    [Fact]
+    public async Task LifterRegistry_CombinesMultipleLanguages()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "hybrid-app",
+            "version": "1.0.0",
+            "dependencies": { "express": "^4.0.0" }
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var csproj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <TargetFramework>net8.0</TargetFramework>
+            <AssemblyName>HybridBackend</AssemblyName>
+          </PropertyGroup>
+          <ItemGroup>
+            <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.0" />
+          </ItemGroup>
+        </Project>
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "Backend.csproj"), csproj);
+
+        var registry = new ReachabilityLifterRegistry();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-006"
+        };
+
+        // Act
+        var graph = await registry.LiftAllAsync(context, CancellationToken.None);
+
+        // Assert
+        registry.Lifters.Should().HaveCountGreaterOrEqualTo(2);
+        graph.Nodes.Should().Contain(n => n.Lang == "node");
+        graph.Nodes.Should().Contain(n => n.Lang == "dotnet");
+    }
+
+    [Fact]
+    public async Task LifterRegistry_SelectsSpecificLanguages()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "node-only",
+            "version": "1.0.0"
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var registry = new ReachabilityLifterRegistry();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-analysis-007"
+        };
+
+        // Act
+        var graph = await registry.LiftAsync(context, new[] { "node" }, CancellationToken.None);
+
+        // Assert
+        graph.Nodes.Should().OnlyContain(n => n.Lang == "node");
+    }
+
+    [Fact]
+    public async Task LifterRegistry_LiftAndWrite_CreatesOutputFiles()
+    {
+        // Arrange
+        var packageJson = """
+        {
+            "name": "write-test",
+            "version": "1.0.0",
+            "dependencies": { "lodash": "^4.0.0" }
+        }
+        """;
+        await File.WriteAllTextAsync(Path.Combine(_tempDir, "package.json"), packageJson);
+
+        var outputDir = Path.Combine(_tempDir, "output");
+        Directory.CreateDirectory(outputDir);
+
+        var registry = new ReachabilityLifterRegistry();
+        var context = new ReachabilityLifterContext
+        {
+            RootPath = _tempDir,
+            AnalysisId = "test-write-001"
+        };
+
+        // Act
+        var result = await registry.LiftAndWriteAsync(context, outputDir, CancellationToken.None);
+
+        // Assert
+        result.Should().NotBeNull();
+        File.Exists(result.MetaPath).Should().BeTrue();
+        File.Exists(result.Nodes.Path).Should().BeTrue();
+        File.Exists(result.Edges.Path).Should().BeTrue();
+        result.Nodes.RecordCount.Should().BeGreaterThan(0);
+    }
+
+    [Fact]
+    public void GraphBuilder_AddsRichNodes()
+    {
+        // Arrange
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        builder.AddNode(
+            symbolId: "sym:test:abc123",
+            lang: "test",
+            kind: "function",
+            display: "myFunction",
+            sourceFile: "src/main.ts",
+            sourceLine: 42,
+            attributes: new System.Collections.Generic.Dictionary<string, string>
+            {
+                ["visibility"] = "public",
+                ["async"] = "true"
+            });
+
+        var graph = builder.ToUnionGraph("test");
+
+        // Assert
+        graph.Nodes.Should().HaveCount(1);
+        var node = graph.Nodes.First();
+        node.SymbolId.Should().Be("sym:test:abc123");
+        node.Lang.Should().Be("test");
+        node.Kind.Should().Be("function");
+        node.Display.Should().Be("myFunction");
+        node.Attributes.Should().ContainKey("visibility");
+        node.Source.Should().NotBeNull();
+        node.Source!.Evidence.Should().Contain("src/main.ts:42");
+    }
+
+    [Fact]
+    public void GraphBuilder_AddsRichEdges()
+    {
+        // Arrange
+        var builder = new ReachabilityGraphBuilder();
+
+        // Act
+        builder.AddEdge(
+            from: "sym:test:from",
+            to: "sym:test:to",
+            edgeType: EdgeTypes.Call,
+            confidence: EdgeConfidence.High,
+            origin: "static",
+            provenance: Provenance.Il,
+            evidence: "file:src/main.cs:100");
+
+        var graph = builder.ToUnionGraph("test");
+
+        // Assert
+        graph.Edges.Should().HaveCount(1);
+        var edge = graph.Edges.First();
+        edge.From.Should().Be("sym:test:from");
+        edge.To.Should().Be("sym:test:to");
+        edge.EdgeType.Should().Be("call");
+        edge.Confidence.Should().Be("high");
+        edge.Source.Should().NotBeNull();
+        edge.Source!.Origin.Should().Be("static");
+        edge.Source.Provenance.Should().Be("il");
+    }
+}