VirtualFileSystemTests.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ManagedCode.Storage.Core.Helpers;
using ManagedCode.Storage.Core.Models;
using ManagedCode.Storage.VirtualFileSystem.Core;
using ManagedCode.Storage.VirtualFileSystem.Options;
using ManagedCode.Storage.VirtualFileSystem.Exceptions;
using ManagedCode.Storage.Tests.VirtualFileSystem.Fixtures;
using ManagedCode.Storage.Tests.Common;
using Shouldly;
using Xunit;

namespace ManagedCode.Storage.Tests.VirtualFileSystem;

public abstract class VirtualFileSystemTests<TFixture> : IClassFixture<TFixture>
    where TFixture : class, IVirtualFileSystemFixture
{
    private readonly TFixture _fixture;

    protected VirtualFileSystemTests(TFixture fixture)
    {
        _fixture = fixture;
    }

    private Task<VirtualFileSystemTestContext> CreateContextAsync() => _fixture.CreateContextAsync();
    private VirtualFileSystemCapabilities Capabilities => _fixture.Capabilities;

    public static IEnumerable<object[]> UnicodeFolderTestCases => new[]
    {
        new object[] { "Українська-папка", "лист-привіт", "Привіт з Києва!" },
        new object[] { "中文目錄", "測試文件", "雲端中的內容" },
        new object[] { "日本語ディレクトリ", "テストファイル", "東京からこんにちは" },
        new object[] { "한국어_폴더", "테스트-파일", "부산에서 안녕하세요" },
        new object[] { "emoji📁", "😀-файл", "multi🌐lingual content" }
    };

    [Fact]
    public async Task WriteAndReadFile_ShouldRoundtrip()
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        var file = await vfs.GetFileAsync(new VfsPath("/docs/readme.txt"));
        await file.WriteAllTextAsync("Hello Virtual FS!");

        var content = await file.ReadAllTextAsync();
        content.ShouldBe("Hello Virtual FS!");

        (await vfs.FileExistsAsync(new VfsPath("/docs/readme.txt"))).ShouldBeTrue();
    }

    [Fact]
    public async Task FileExistsAsync_ShouldCacheResults()
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;
        var metadataManager = context.MetadataManager;

        var path = new VfsPath("/cache/sample.txt");
        var file = await vfs.GetFileAsync(path);
        await file.WriteAllTextAsync("cached");

        metadataManager.ResetCounters();
        var firstCheck = await vfs.FileExistsAsync(path);
        firstCheck.ShouldBeTrue();
        metadataManager.BlobInfoRequests.ShouldBe(1);

        metadataManager.ResetCounters();
        var secondCheck = await vfs.FileExistsAsync(path);
        secondCheck.ShouldBeTrue();
        metadataManager.BlobInfoRequests.ShouldBe(0);
    }

    [Fact]
    public async Task ListAsync_ShouldEnumerateAllEntries()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsListing)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;
        var metadataManager = context.MetadataManager;

        for (var i = 0; i < 5; i++)
        {
            var file = await vfs.GetFileAsync(new VfsPath($"/reports/file-{i}.txt"));
            await file.WriteAllTextAsync($"report-{i}");
        }

        var sampleMetadata = await metadataManager.GetBlobInfoAsync("reports/file-0.txt");
        sampleMetadata.ShouldNotBeNull();
        sampleMetadata!.FullName.ShouldBe("reports/file-0.txt");

        var entries = new List<IVfsNode>();
        await foreach (var entry in vfs.ListAsync(new VfsPath("/reports"), new ListOptions { PageSize = 2 }))
        {
            entries.Add(entry);
        }

        var fileEntries = entries.OfType<IVirtualFile>().ToList();
        fileEntries.Count.ShouldBe(5);
        var names = fileEntries.Select(f => f.Path.GetFileName()).OrderBy(n => n).ToList();
        names.ShouldBe(new[]
        {
            "file-0.txt", "file-1.txt", "file-2.txt", "file-3.txt", "file-4.txt"
        });
    }

    [Fact]
    public async Task DeleteFile_ShouldRemoveFromUnderlyingStorage()
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;
        var metadataManager = context.MetadataManager;

        var path = new VfsPath("/temp/remove.me");
        var file = await vfs.GetFileAsync(path);
        await file.WriteAllTextAsync("to delete");

        metadataManager.ResetCounters();
        await vfs.FileExistsAsync(path);
        metadataManager.ResetCounters();

        var deleted = await file.DeleteAsync();
        deleted.ShouldBeTrue();

        var existsAfterDelete = await vfs.FileExistsAsync(path);
        existsAfterDelete.ShouldBeFalse();
        metadataManager.BlobInfoRequests.ShouldBe(1);

        metadataManager.ResetCounters();
        var secondCheck = await vfs.FileExistsAsync(path);
        secondCheck.ShouldBeFalse();
        metadataManager.BlobInfoRequests.ShouldBe(0);
    }

    [Fact]
    public async Task GetMetadataAsync_ShouldCacheCustomMetadata()
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;
        var metadataManager = context.MetadataManager;

        var file = await vfs.GetFileAsync(new VfsPath("/meta/info.txt"));
        await file.WriteAllTextAsync("meta");

        await file.SetMetadataAsync(new Dictionary<string, string>
        {
            ["owner"] = "qa",
            ["region"] = "eu"
        });

        metadataManager.ResetCounters();
        var metadata = await file.GetMetadataAsync();
        metadata.ShouldContainKey("owner");
        metadataManager.CustomMetadataRequests.ShouldBe(1);

        metadataManager.ResetCounters();
        var secondLookup = await file.GetMetadataAsync();
        secondLookup.ShouldContainKey("region");
        metadataManager.CustomMetadataRequests.ShouldBe(0);
    }

    [Theory]
    [MemberData(nameof(UnicodeFolderTestCases))]
    public async Task WriteAndReadFile_WithUnicodeDirectories_ShouldRoundtrip(
        string directoryName,
        string fileName,
        string content)
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        var path = new VfsPath($"/international/{directoryName}/{fileName}.txt");
        var file = await vfs.GetFileAsync(path);

        await file.WriteAllTextAsync(content);

        (await file.ReadAllTextAsync()).ShouldBe(content);
        file.Path.GetFileName().ShouldBe($"{fileName}.txt");
        file.Path.GetFileNameWithoutExtension().ShouldBe(fileName);
        file.Path.GetExtension().ShouldBe(".txt");
        file.Path.GetParent().Value.ShouldBe($"/international/{directoryName}");
        file.Path.ToBlobKey().ShouldBe($"international/{directoryName}/{fileName}.txt");

        (await vfs.FileExistsAsync(path)).ShouldBeTrue();

        if (Capabilities.SupportsListing)
        {
            var entries = new List<IVfsNode>();
            await foreach (var entry in vfs.ListAsync(new VfsPath($"/international/{directoryName}"), new ListOptions
            {
                IncludeFiles = true,
                IncludeDirectories = false,
                Recursive = false
            }))
            {
                entries.Add(entry);
            }

            entries.ShouldContain(e => e.Path.Value == path.Value);
        }

        (await file.DeleteAsync()).ShouldBeTrue();
        (await vfs.FileExistsAsync(path)).ShouldBeFalse();
    }

    [Fact]
    public async Task DeleteDirectoryAsync_NonRecursive_ShouldPreserveNestedContent()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsDirectoryDelete)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        await (await vfs.GetFileAsync(new VfsPath("/nonrec/root.txt"))).WriteAllTextAsync("root");
        await (await vfs.GetFileAsync(new VfsPath("/nonrec/sub/nested.txt"))).WriteAllTextAsync("child");

        var result = await vfs.DeleteDirectoryAsync(new VfsPath("/nonrec"), recursive: false);
        result.FilesDeleted.ShouldBe(1);

        (await vfs.FileExistsAsync(new VfsPath("/nonrec/root.txt"))).ShouldBeFalse();
        (await vfs.FileExistsAsync(new VfsPath("/nonrec/sub/nested.txt"))).ShouldBeTrue();
    }

    [Fact]
    public async Task DeleteDirectoryAsync_Recursive_ShouldRemoveAllContent()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsDirectoryDelete)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        await (await vfs.GetFileAsync(new VfsPath("/recursive/root.txt"))).WriteAllTextAsync("root");
        await (await vfs.GetFileAsync(new VfsPath("/recursive/sub/nested.txt"))).WriteAllTextAsync("child");

        var result = await vfs.DeleteDirectoryAsync(new VfsPath("/recursive"), recursive: true);
        result.FilesDeleted.ShouldBe(2);

        (await vfs.FileExistsAsync(new VfsPath("/recursive/root.txt"))).ShouldBeFalse();
        (await vfs.FileExistsAsync(new VfsPath("/recursive/sub/nested.txt"))).ShouldBeFalse();
    }

    [Fact]
    public async Task MoveAsync_ShouldRelocateFile()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsMove)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        var sourcePath = new VfsPath("/docs/report.pdf");
        var destPath = new VfsPath("/archive/report.pdf");
        var file = await vfs.GetFileAsync(sourcePath);
        await file.WriteAllBytesAsync(new byte[] { 1, 2, 3, 4 });

        await vfs.MoveAsync(sourcePath, destPath);

        var moved = await vfs.GetFileAsync(destPath);
        var bytes = await moved.ReadAllBytesAsync();
        bytes.ShouldBe(new byte[] { 1, 2, 3, 4 });

        var original = await vfs.GetFileAsync(sourcePath);
        await Should.ThrowAsync<VfsException>(() => original.ReadAllBytesAsync());
    }

    [Fact]
    public async Task CopyAsync_ShouldCopyDirectoryRecursively()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsDirectoryCopy)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        for (var i = 0; i < 3; i++)
        {
            var file = await vfs.GetFileAsync(new VfsPath($"/src/data-{i}.bin"));
            await file.WriteAllBytesAsync(new byte[] { (byte)i });
        }

        var nested = await vfs.GetFileAsync(new VfsPath("/src/nested/item.txt"));
        await nested.WriteAllTextAsync("nested");

        await vfs.CopyAsync(new VfsPath("/src"), new VfsPath("/dest"), new CopyOptions { Recursive = true, Overwrite = true });

        for (var i = 0; i < 3; i++)
        {
            var copied = await vfs.GetFileAsync(new VfsPath($"/dest/data-{i}.bin"));
            var bytes = await copied.ReadAllBytesAsync();
            bytes.ShouldBe(new byte[] { (byte)i });
        }

        var copiedNested = await vfs.GetFileAsync(new VfsPath("/dest/nested/item.txt"));
        (await copiedNested.ReadAllTextAsync()).ShouldBe("nested");
    }

    [Fact]
    public async Task ReadRangeAsync_ShouldReturnSlice()
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        var file = await vfs.GetFileAsync(new VfsPath("/ranges/sample.bin"));
        await file.WriteAllBytesAsync(Enumerable.Range(0, 100).Select(i => (byte)i).ToArray());

        var slice = await file.ReadRangeAsync(0, 5);
        slice.ShouldBe(new byte[] { 0, 1, 2, 3, 4 });
    }

    [Fact]
    public async Task ListAsync_WithDirectoryFilter_ShouldExcludeDirectoriesWhenRequested()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsListing)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        await (await vfs.GetFileAsync(new VfsPath("/filter/a.txt"))).WriteAllTextAsync("A");
        await (await vfs.GetFileAsync(new VfsPath("/filter/b.log"))).WriteAllTextAsync("B");

        var entries = new List<IVfsNode>();
        await foreach (var entry in vfs.ListAsync(new VfsPath("/filter"), new ListOptions
        {
            IncludeDirectories = false,
            IncludeFiles = true,
            Recursive = false
        }))
        {
            entries.Add(entry);
        }

        entries.Count.ShouldBe(2);
        entries.ShouldAllBe(e => e.Type == VfsEntryType.File);

        var paths = entries.OfType<IVirtualFile>().Select(e => e.Path.Value).OrderBy(v => v).ToList();
        paths.ShouldBe(new[] { "/filter/a.txt", "/filter/b.log" });
    }

    [Fact]
    public async Task DirectoryStats_ShouldAggregateInformation()
    {
        if (!Capabilities.Enabled || !Capabilities.SupportsDirectoryStats)
        {
            return;
        }

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        await (await vfs.GetFileAsync(new VfsPath("/stats/one.txt"))).WriteAllTextAsync("one");
        await (await vfs.GetFileAsync(new VfsPath("/stats/two.bin"))).WriteAllBytesAsync(new byte[] { 1, 2, 3, 4 });

        var directory = await vfs.GetDirectoryAsync(new VfsPath("/stats"));
        var stats = await directory.GetStatsAsync();

        stats.FileCount.ShouldBeGreaterThanOrEqualTo(2);
        stats.FilesByExtension.ShouldContainKey(".txt");
        stats.FilesByExtension.ShouldContainKey(".bin");
    }

    [Theory]
    [Trait("Category", "LargeFile")]
    [InlineData(1)]
    [InlineData(3)]
    [InlineData(5)]
    public async Task LargeFile_ShouldRoundTripViaStreams(int gigabytes)
    {
        if (!Capabilities.Enabled)
        {
            return;
        }

        var sizeBytes = LargeFileTestHelper.ResolveSizeBytes(gigabytes);

        await using var context = await CreateContextAsync();
        var vfs = context.FileSystem;

        await using var sourceFile = await LargeFileTestHelper.CreateRandomFileAsync(sizeBytes, ".bin");
        var expectedCrc = LargeFileTestHelper.CalculateFileCrc(sourceFile.FilePath);

        var path = new VfsPath($"/large/{Guid.NewGuid():N}.bin");
        var file = await vfs.GetFileAsync(path);

        await using (var writeStream = await file.OpenWriteAsync(cancellationToken: CancellationToken.None))
        await using (var readSource = File.OpenRead(sourceFile.FilePath))
        {
            await readSource.CopyToAsync(writeStream, cancellationToken: CancellationToken.None);
        }

        await using (var readBack = await file.OpenReadAsync(cancellationToken: CancellationToken.None))
        {
            var actualCrc = Crc32Helper.CalculateStreamCrc(readBack);
            actualCrc.ShouldBe(expectedCrc);
        }

        (await file.DeleteAsync()).ShouldBeTrue();
    }
}

[Collection(VirtualFileSystemCollection.Name)]
public sealed class FileSystemVirtualFileSystemTests : VirtualFileSystemTests<FileSystemVirtualFileSystemFixture>
{
    public FileSystemVirtualFileSystemTests(FileSystemVirtualFileSystemFixture fixture) : base(fixture)
    {
    }
}

[Collection(VirtualFileSystemCollection.Name)]
public sealed class AzureVirtualFileSystemTests : VirtualFileSystemTests<AzureVirtualFileSystemFixture>
{
    public AzureVirtualFileSystemTests(AzureVirtualFileSystemFixture fixture) : base(fixture)
    {
    }
}

[Collection(VirtualFileSystemCollection.Name)]
public sealed class AwsVirtualFileSystemTests : VirtualFileSystemTests<AwsVirtualFileSystemFixture>
{
    public AwsVirtualFileSystemTests(AwsVirtualFileSystemFixture fixture) : base(fixture)
    {
    }
}

[Collection(VirtualFileSystemCollection.Name)]
public sealed class GcsVirtualFileSystemTests : VirtualFileSystemTests<GcsVirtualFileSystemFixture>
{
    public GcsVirtualFileSystemTests(GcsVirtualFileSystemFixture fixture) : base(fixture)
    {
    }
}

[Collection(VirtualFileSystemCollection.Name)]
public sealed class SftpVirtualFileSystemTests : VirtualFileSystemTests<SftpVirtualFileSystemFixture>
{
    public SftpVirtualFileSystemTests(SftpVirtualFileSystemFixture fixture) : base(fixture)
    {
    }
}