XisoExplorerKeepOpenTests.cs

using System.Diagnostics.CodeAnalysis;
using System.Security.Cryptography;
using XISOSharp.Models;

namespace XISOSharp.Tests;

/// <summary>
/// Keep-open explorer mode (2.2): one held image stream for the explorer's
/// lifetime, an internal lock serializing operations, and a dispose that
/// releases both the stream and every read stream handed out. The stateless
/// default must stay byte-for-byte unchanged.
/// </summary>
[Collection("Sequential")]
public sealed class XisoExplorerKeepOpenTests : IDisposable
{
    private readonly List<string> _tempDirs = [];
    private readonly bool _savedQuiet;
    private readonly bool _savedRealQuiet;

    public XisoExplorerKeepOpenTests()
    {
        _savedQuiet = Logger.Quiet;
        _savedRealQuiet = Logger.RealQuiet;
    }

    public void Dispose()
    {
        Logger.Quiet = _savedQuiet;
        Logger.RealQuiet = _savedRealQuiet;

        foreach (string dir in _tempDirs)
        {
            try
            {
                if (Directory.Exists(dir)) Directory.Delete(dir, true);
            }
            catch
            {
                // ignored
            }
        }
    }

    private string CreateTempDir(string prefix)
    {
        string dir = Path.Combine(Path.GetTempPath(), $"{prefix}_{Guid.NewGuid():N}");
        Directory.CreateDirectory(dir);
        _tempDirs.Add(dir);
        return dir;
    }

    private string CreateIso()
    {
        string src = CreateTempDir("xiso_keep_src");
        File.WriteAllText(Path.Combine(src, "a.txt"), "hello");
        File.WriteAllText(Path.Combine(src, "b.txt"), new string('x', 3000));
        Directory.CreateDirectory(Path.Combine(src, "sub"));
        File.WriteAllText(Path.Combine(src, "sub", "c.txt"), "nested");
        File.WriteAllBytes(Path.Combine(src, "empty.bin"), []);

        string outDir = CreateTempDir("xiso_keep_iso");
        int result = XisoWriter.CreateXiso(src, outDir, null, null, out string? isoPath, null, null);
        Assert.Equal(0, result);
        Assert.NotNull(isoPath);
        return isoPath;
    }

    [Fact]
    public void KeepOpen_OperationsMatchStatelessExplorer()
    {
        string iso = CreateIso();
        using XisoExplorer stateful = new(iso, new XisoExplorerOptions { KeepOpen = true });
        XisoExplorer stateless = new(iso);

        Assert.True(stateful.IsKeepOpen);
        Assert.False(stateless.IsKeepOpen);
        Assert.Equal(stateless.Volume, stateful.Volume);

        Assert.Equal(stateless.ListChildren("/"), stateful.ListChildren("/"));
        Assert.Equal(stateless.ListChildren("/sub"), stateful.ListChildren("/sub"));
        Assert.Equal(stateless.GetNode("/a.txt"), stateful.GetNode("/a.txt"));
        Assert.Equal(stateless.GetNode("/sub/c.txt"), stateful.GetNode("/sub/c.txt"));
        Assert.Equal(stateless.GetNode("/missing"), stateful.GetNode("/missing"));
        Assert.Equal(stateless.ComputeHashHex("/b.txt", HashAlgorithmName.SHA256),
            stateful.ComputeHashHex("/b.txt", HashAlgorithmName.SHA256));
        Assert.Equal(stateless.Volume.DiscFormat, stateful.Volume.DiscFormat);
        Assert.Equal(stateless.Volume.CreationTime, stateful.Volume.CreationTime);
        Assert.Equal(stateless.Volume.DescriptorSector, stateful.Volume.DescriptorSector);
    }

    [Fact]
    [SuppressMessage("ReSharper", "AccessToDisposedClosure")]
    public void KeepOpen_ParallelMetadataOperations_Smoke()
    {
        string iso = CreateIso();
        using XisoExplorer explorer = new(iso, new XisoExplorerOptions { KeepOpen = true });
        Parallel.For(0, 64, i =>
        {
            switch (i % 4)
            {
                case 0:
                    Assert.Equal(4, explorer.ListChildren("/").Count);
                    break;
                case 1:
                    Assert.Equal("a.txt", explorer.GetNode("/a.txt")!.Name);
                    break;
                case 2:
                    Assert.NotNull(explorer.ComputeHashHex("/b.txt", HashAlgorithmName.SHA256));
                    break;
                default:
                    Assert.Equal("c.txt", explorer.ListChildren("/sub").Single().Name);
                    break;
            }
        });
    }

    [Fact]
    public void KeepOpen_DisposeThenOperate_ThrowsObjectDisposed()
    {
        string iso = CreateIso();
        XisoExplorer explorer = new(iso, new XisoExplorerOptions { KeepOpen = true });
        explorer.Dispose();

        Assert.Throws<ObjectDisposedException>(() => explorer.ListChildren("/"));
        Assert.Throws<ObjectDisposedException>(() => explorer.GetNode("/"));
        Assert.Throws<ObjectDisposedException>(() => explorer.GetNode("/a.txt"));
        Assert.Throws<ObjectDisposedException>(() => explorer.OpenReadStream("/a.txt"));
        Assert.Throws<ObjectDisposedException>(() => explorer.ComputeHashHex("/a.txt", HashAlgorithmName.SHA256));
    }

    [Fact]
    public void KeepOpen_DoubleDispose_IsHarmless()
    {
        string iso = CreateIso();
        XisoExplorer explorer = new(iso, new XisoExplorerOptions { KeepOpen = true });

        explorer.Dispose();
        explorer.Dispose();
    }

    [Fact]
    public void KeepOpen_OpenReadStreamDiesWithExplorer()
    {
        string iso = CreateIso();
        XisoExplorer explorer = new(iso, new XisoExplorerOptions { KeepOpen = true });
        using Stream stream = explorer.OpenReadStream("/a.txt");
        Assert.Equal("hello".Length, stream.Read(new byte[16]));

        explorer.Dispose();

        // The held parent stream is gone; a read that reaches the parent throws.
        stream.Seek(0, SeekOrigin.Begin);
        Assert.Throws<ObjectDisposedException>(() => stream.Read(new byte[16]));
    }

    [Fact]
    public void Stateless_DisposeIsHarmlessAndOperationsKeepWorking()
    {
        string iso = CreateIso();
        XisoExplorer explorer = new(iso);
        explorer.Dispose();

        // Stateless mode owns no stream: disposing the explorer is a no-op and
        // per-call streams keep the documented behavior.
        Assert.False(explorer.IsKeepOpen);
        Assert.Equal(4, explorer.ListChildren("/").Count);
        Assert.NotNull(explorer.GetNode("/a.txt"));
    }

    [Fact]
    public void KeepOpen_ShareParameterIsExposed()
    {
        string iso = CreateIso();
        using XisoExplorer explorer = new(iso, new XisoExplorerOptions
        {
            KeepOpen = true,
            Share = FileShare.ReadWrite,
        });

        Assert.Equal(FileShare.ReadWrite, explorer.Options.Share);
        Assert.True(explorer.Volume.IsValid);
    }
}