git.stella-ops.org/src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Bun.Tests/Bun/BunLanguageAnalyzerTests.cs

using StellaOps.Scanner.Analyzers.Lang.Bun;
using Xunit;
using StellaOps.Scanner.Analyzers.Lang.Tests.Harness;
using StellaOps.Scanner.Analyzers.Lang.Tests.TestUtilities;

namespace StellaOps.Scanner.Analyzers.Lang.Bun.Tests;

public sealed class BunLanguageAnalyzerTests
{
    [Fact]
    public async Task StandardInstallProducesDeterministicOutputAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "standard");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task IsolatedLinkerInstallIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "isolated");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task LockfileOnlyIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "lockfile-only");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task BinaryLockfileEmitsRemediationAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "binary-lockfile");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task WorkspacesAreParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "workspaces");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task SymlinkSafetyIsEnforcedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "symlinks");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task ScopedPackagesAreParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "scoped-packages");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task GitDependenciesAreParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "git-dependencies");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task CustomRegistryIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "custom-registry");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task PatchedPackagesAreParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "patched-packages");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task PatchedMultiVersionIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "patched-multi-version");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task DeepDependencyTreeIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "deep-tree");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task MultiWorkspaceIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "multi-workspace");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task JsoncLockfileIsParsedAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "jsonc-lockfile");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task ContainerLayersAreDiscoveredAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "container-layers");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task BunfigOnlyEmitsDeclaredOnlyAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "bunfig-only");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task LockfileDevClassificationIsDeterministicAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "lockfile-dev-classification");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }

    [Fact]
    public async Task NonConcreteVersionsUseExplicitKeyAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "bun", "non-concrete-versions");
        var goldenPath = Path.Combine(fixturePath, "expected.json");

        var analyzers = new ILanguageAnalyzer[]
        {
            new BunLanguageAnalyzer()
        };

        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
            fixturePath,
            goldenPath,
            analyzers,
            cancellationToken);
    }
}