Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

9.2 KB
Raw Blame
using System.Text.Json;
using Aetheris.Kernel.Core.Step242;

namespace Aetheris.CLI.Tests;

public sealed class RuledStepProbeHarnessTests
{
    private static readonly string RepoRoot = FindRepoRoot();

    [Fact]
    public void OpenRuledProbeRemainsInspectableButCannotBeExportedAsAProductionSolid()
    {
        var sourceProbe = Path.Combine(RepoRoot, "testdata", "step242", "generated", "ruled-a2", "ellipse-linear-extrusion-production.step");
        Assert.True(File.Exists(sourceProbe), $"Expected ruled production probe at '{sourceProbe}'.");

        var root = Path.Combine(Path.GetTempPath(), "aetheris-ruled-step-probe", Guid.NewGuid().ToString("N"));
        var inputDir = Path.Combine(root, "input");
        var wrapperDir = Path.Combine(root, "wrapper");
        var outputDir = Path.Combine(root, "output");
        Directory.CreateDirectory(inputDir);
        Directory.CreateDirectory(wrapperDir);
        Directory.CreateDirectory(outputDir);

        const string probeName = "ellipseLinearExtrusionProduction";
        var originalProbeName = Path.GetFileName(sourceProbe);
        var rawProbeCopy = Path.Combine(inputDir, originalProbeName);
        var canonicalInput = Path.Combine(inputDir, probeName + ".canonical-input.step");
        var wrapperPath = Path.Combine(wrapperDir, probeName + ".firm");
        var outputStepPath = Path.Combine(outputDir, probeName + ".canonical.step");

        File.Copy(sourceProbe, rawProbeCopy, overwrite: true);

        try
        {
            foreach (var mode in new[] { "production", "deterministic" })
            {
                var canon = RunCli("canon", rawProbeCopy, "--out", canonicalInput, "--mode", mode, "--json");
                Assert.NotEqual(0, canon.ExitCode);
                Assert.Contains("brep-preflight-imported-shell-not-enclosed", canon.StdOut);
                Assert.False(File.Exists(canonicalInput));
            }
            var wrapper = BuildWrapperSource(probeName, originalProbeName);
            File.WriteAllText(wrapperPath, wrapper);

            Assert.Equal(Path.Combine(wrapperDir, "ellipseLinearExtrusionProduction.firm"), wrapperPath);
            Assert.Equal(Path.Combine(outputDir, "ellipseLinearExtrusionProduction.canonical.step"), outputStepPath);
            Assert.Contains("InlineStep", wrapper, StringComparison.Ordinal);
            Assert.Contains("../input/" + originalProbeName, wrapper, StringComparison.Ordinal);

            var build = RunCli("build", wrapperPath, "--out", outputStepPath, "--json");
            Assert.NotEqual(0, build.ExitCode);
            Assert.Contains("brep-preflight-imported-shell-not-enclosed", build.StdOut);
            Assert.False(File.Exists(outputStepPath));

            var stepText = File.ReadAllText(rawProbeCopy);
            Assert.Contains("SURFACE_OF_LINEAR_EXTRUSION", stepText, StringComparison.Ordinal);
            Assert.Contains("ELLIPSE", stepText, StringComparison.Ordinal);
            Assert.DoesNotContain("B_SPLINE_SURFACE_WITH_KNOTS", stepText, StringComparison.Ordinal);

            var import = Step242Importer.ImportBody(stepText);
            Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.Contains(import.Value.Geometry.Surfaces, entry => entry.Value.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.LinearExtrusion);

            Assert.False(import.Value.ImportQualification!.Shells.Single().Enclosed);
            Assert.Equal(4, import.Value.ImportQualification.Shells.Single().BoundaryEdges);
            var analyze = RunCli("analyze", rawProbeCopy, "--json");
            using var doc = JsonDocument.Parse(analyze.StdOut);
            if (analyze.ExitCode == 0)
            {
                var summary = doc.RootElement.GetProperty("summary");
                Assert.Equal(1, summary.GetProperty("bodyCount").GetInt32());
                Assert.True(summary.GetProperty("faceCount").GetInt32() >= 1);
            }
            else
            {
                Assert.False(doc.RootElement.GetProperty("success").GetBoolean());
                Assert.True(doc.RootElement.TryGetProperty("errorKind", out _));
            }
        }
        finally
        {
            if (Directory.Exists(root))
            {
                Directory.Delete(root, recursive: true);
            }
        }
    }

    [Theory]
    [InlineData("production")]
    [InlineData("deterministic")]
    public void ClosedEllipsePartPassesTheSameStrictCanonBoundary(string mode)
    {
        var root = Path.Combine(RepoRoot, "artifacts", "local", "test", "closed-ruled", Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(root);
        var input = Path.Combine(root, "closed.step"); var output = Path.Combine(root, "canonical.step");
        var build = RunCli("build", Path.Combine(RepoRoot, "fixtures/Canonical/Boundary2/closed-ellipse-extrusion.firmament"), "--out", input, "--json");
        Assert.True(build.ExitCode == 0, build.StdOut + build.StdErr);
        var canon = RunCli("canon", input, "--out", output, "--mode", mode, "--json");
        Assert.True(canon.ExitCode == 0, canon.StdOut + canon.StdErr);
        var text = File.ReadAllText(output);
        Assert.Contains("SURFACE_OF_LINEAR_EXTRUSION", text); Assert.Contains("ELLIPSE", text);
        var imported = Step242Importer.ImportBody(text); Assert.True(imported.IsSuccess);
        Assert.True(imported.Value.ImportQualification!.Shells.Single().Enclosed);
    }

    [Theory]
    [InlineData("production")]
    [InlineData("deterministic")]
    public void CanonMetadataModeDoesNotDiscardSemanticPmi(string mode)
    {
        var root = Path.Combine(RepoRoot, "artifacts", "local", "test", "canon-pmi", Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(root);
        var input = Path.Combine(root, "part.step"); var output = Path.Combine(root, "canonical.step");
        var built = RunCli("build", Path.Combine(RepoRoot, "fixtures/Canonical/PMI/explicit-gdt.firmament"), "--out", input, "--json");
        Assert.True(built.ExitCode == 0, built.StdOut + built.StdErr);
        var result = RunCli("canon", input, "--out", output, "--mode", mode, "--json");
        Assert.True(result.ExitCode == 0, result.StdOut + result.StdErr);
        var pmi = Step242SemanticPmiInspector.Inspect(File.ReadAllText(output));
        Assert.Equal(3, pmi.DatumCount); Assert.Equal(3, pmi.GeometricToleranceCount);
        Assert.All(pmi.Items, item => Assert.NotEmpty(item.GeometricFaceEntityIds));
        using var report = JsonDocument.Parse(result.StdOut);
        Assert.Equal(JsonValueKind.Array, report.RootElement.GetProperty("diagnostics").ValueKind);
    }

    [Fact]
    public void Harness_Documentation_And_Script_Are_Present_And_Reference_InlineStep()
    {
        var scriptPath = Path.Combine(RepoRoot, "tools", "Run-RuledStepProbe.ps1");
        var docPath = Path.Combine(RepoRoot, "docs", "development", "implementation", "ruled-tooling-a0-inline-step-probe-harness.md");
        var ruledA2Path = Path.Combine(RepoRoot, "docs", "development", "implementation", "ruled-a2-linear-extrusion-production-and-snapshot-refresh.md");

        Assert.True(File.Exists(scriptPath), $"Expected ruled probe script at '{scriptPath}'.");
        Assert.True(File.Exists(docPath), $"Expected ruled probe doc at '{docPath}'.");

        var script = File.ReadAllText(scriptPath);
        Assert.Contains("param(", script, StringComparison.Ordinal);
        Assert.Contains("InlineStep", script, StringComparison.Ordinal);
        Assert.Contains("probe-report.json", script, StringComparison.Ordinal);
        Assert.Contains("Validate-Step-FreeCAD.ps1", script, StringComparison.Ordinal);

        var doc = File.ReadAllText(docPath);
        Assert.Contains("Run-RuledStepProbe.ps1", doc, StringComparison.Ordinal);
        Assert.Contains("InlineStep", doc, StringComparison.Ordinal);
        Assert.Contains("tooling only", doc, StringComparison.OrdinalIgnoreCase);
        Assert.Contains("artifacts/local/demos/ruled-probes/<probe-name>/", doc, StringComparison.Ordinal);

        var ruledA2 = File.ReadAllText(ruledA2Path);
        Assert.Contains("ruled-tooling-a0-inline-step-probe-harness.md", ruledA2, StringComparison.Ordinal);
    }

    private static string BuildWrapperSource(string identifier, string stagedFileName) =>
        $@"model {identifier}ProbeHarness {{
    units mm

    solid {identifier}: InlineStep {{
        path: ""../input/{stagedFileName}""
    }}
}}";

    private static (int ExitCode, string StdOut, string StdErr) RunCli(params string[] args)
    {
        var stdout = new StringWriter();
        var stderr = new StringWriter();
        var exitCode = CliRunner.Run(args, stdout, stderr);
        return (exitCode, stdout.ToString(), stderr.ToString());
    }

    private static string FindRepoRoot()
    {
        var directory = new DirectoryInfo(AppContext.BaseDirectory);
        while (directory is not null)
        {
            if (File.Exists(Path.Combine(directory.FullName, "Aetheris.slnx")))
            {
                return directory.FullName;
            }

            directory = directory.Parent;
        }

        throw new InvalidOperationException("Unable to locate repository root for ruled probe tests.");
    }
}