Explorer-Workbench/tests/Explorer.Hosting.Tests/CoreRegistrationTests.cs

using Explorer.Contracts;
using Explorer.Domain;
using Explorer.Domain.Abstractions;
using Explorer.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace Explorer.Hosting.Tests;

public class CoreRegistrationTests
{
    [Fact]
    public async Task AddExplorerCore_registers_workbench_without_clipboard()
    {
        var dir = Path.Combine(Path.GetTempPath(), "ew-hosting", Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(dir);
        try
        {
            var services = new ServiceCollection();
            services.AddLogging();
            services.AddSingleton<IAppEnvironment>(new TempEnv(dir));
            services.AddExplorerCore();
            await using var sp = services.BuildServiceProvider();
            Assert.NotNull(sp.GetService<IWorkbenchHost>());
            Assert.NotNull(sp.GetService<IIndexingHost>());
            Assert.NotNull(sp.GetService<ITransferHost>());
            Assert.NotNull(sp.GetService<IIndexMutations>());
            Assert.Null(sp.GetService<IOsClipboard>());
        }
        finally
        {
            try { Directory.Delete(dir, true); } catch { /* ignore */ }
        }
    }

    [Fact]
    public async Task AddExplorerClient_uses_read_only_store_without_indexing_workers()
    {
        var dir = Path.Combine(Path.GetTempPath(), "ew-hosting", Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(dir);
        try
        {
            var workbench = new StubWorkbench();
            var services = new ServiceCollection();
            services.AddLogging();
            services.AddSingleton<IAppEnvironment>(new TempEnv(dir));
            services.AddExplorerClient(workbench);
            await using var sp = services.BuildServiceProvider();
            Assert.Same(workbench, sp.GetService<IWorkbenchHost>());
            Assert.Same(workbench.Indexing, sp.GetService<IIndexingHost>());
            Assert.Same(workbench.Transfers, sp.GetService<ITransferHost>());
            Assert.Same(workbench.Sources, sp.GetService<ISourceHost>());
            Assert.Same(workbench.Mutations, sp.GetService<IIndexMutations>());
            Assert.False(sp.GetRequiredService<IIndexStore>().CanWrite);
            var hosted = sp.GetServices<IHostedService>().ToList();
            Assert.Contains(hosted, s => s is IndexStoreLifetime);
            Assert.DoesNotContain(hosted, s => s.GetType().Name is "IndexingCoordinator" or "TransferQueue" or "WatcherHostedService");
        }
        finally
        {
            try { Directory.Delete(dir, true); } catch { /* ignore */ }
        }
    }

    private sealed class TempEnv : IAppEnvironment
    {
        public TempEnv(string dir)
        {
            DataDirectory = dir;
            DatabasePath = Path.Combine(dir, "index.db");
            LogDirectory = Path.Combine(dir, "logs");
            Directory.CreateDirectory(LogDirectory);
        }

        public string DataDirectory { get; }
        public string DatabasePath { get; }
        public string LogDirectory { get; }
    }

    private sealed class StubWorkbench : IWorkbenchHost
    {
        public IIndexingHost Indexing { get; } = new StubIndexing();
        public ITransferHost Transfers { get; } = new StubTransfers();
        public ISourceHost Sources { get; } = new StubSources();
        public IIndexMutations Mutations { get; } = new StubMutations();
    }

    private sealed class StubIndexing : IIndexingHost
    {
        public event EventHandler<ScanProgress>? ProgressChanged = delegate { };
        public void EnqueueFullScan(long sourceId) { }
        public void EnqueueFolderScan(long sourceId, string pathRel) { }
        public void EnqueueReconcile(long sourceId, string pathRel) { }
        public void Cancel(long sourceId) { }
    }

    private sealed class StubTransfers : ITransferHost
    {
        public event EventHandler? Changed = delegate { };
        public event EventHandler<TransferJob>? JobFinished = delegate { };
        public bool IsPaused => false;
        public IReadOnlyList<TransferJob> Snapshot() => [];
        public void PauseAll() { }
        public void ResumeAll() { }
        public void Pause(long jobId) { }
        public void Resume(long jobId) { }
        public void Retry(long jobId) { }
        public void Cancel(long jobId) { }
        public void Dismiss(long jobId) { }
        public void ClearFinished() { }
        public bool MoveUp(long jobId) => false;
        public bool MoveDown(long jobId) => false;
    }

    private sealed class StubSources : ISourceHost
    {
        public Task RefreshAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
        public Task<Source> AddUncAsync(string path, CancellationToken cancellationToken = default)
            => Task.FromResult(new Source { StableKey = "x", DisplayName = path });
        public Task<Source?> EnsureForPathAsync(string path, CancellationToken cancellationToken = default)
            => Task.FromResult<Source?>(null);
        public Task<bool> ForgetAsync(string path, CancellationToken cancellationToken = default)
            => Task.FromResult(false);
    }

    private sealed class StubMutations : IIndexMutations
    {
        public Task<long> UpsertSyncProfileAsync(SyncProfile profile, CancellationToken cancellationToken = default)
            => Task.FromResult(0L);
        public Task DeleteSyncProfileAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
        public Task<long> UpsertOperationProfileAsync(OperationProfile profile, CancellationToken cancellationToken = default)
            => Task.FromResult(0L);
        public Task DeleteOperationProfileAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
        public Task<long> CreateRenameBatchAsync(IReadOnlyList<RenameBatchItem> items, CancellationToken cancellationToken = default)
            => Task.FromResult(0L);
        public Task MarkRenameBatchUndoneAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
        public Task EnqueueHashCollisionsAsync(long? sourceId, CancellationToken cancellationToken = default) => Task.CompletedTask;
        public Task UpsertRelationAsync(FileRelation relation, CancellationToken cancellationToken = default) => Task.CompletedTask;
    }
}