Skip to content

Free, open-source Windows optimization tool for performance, privacy, and simplicity.

15.9 KB
Raw Blame
using Microsoft.Extensions.Logging.Abstractions;
using optimizerDuck.Domain.Attributes;
using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
using optimizerDuck.Domain.UI;
using optimizerDuck.Resources.Languages;
using optimizerDuck.Services.Conditions;
using optimizerDuck.Services.System;

namespace optimizerDuck.Test.Domain.Conditions;

public class ConditionTests
{
    #region Snapshot builder

    private static SystemInfo Snapshot(
        int? build = 22631,
        GpuVendor gpuVendor = GpuVendor.Unknown,
        CpuVendor cpuVendor = CpuVendor.Unknown,
        double ramGb = 0
    ) =>
        new()
        {
            Cpu = new CpuInfo
            {
                Name = "Test CPU",
                Vendor = cpuVendor,
                Architecture = Architecture.X64,
                CoreCount = 8,
                ThreadCount = 16,
                MaxFrequencyMhz = 4000,
                CurrentFrequencyMhz = 4000,
            },
            Memory = new MemoryInfo
            {
                TotalBytes = (long)(ramGb * 1024 * 1024 * 1024),
                AvailableBytes = (long)(ramGb * 1024 * 1024 * 1024),
                Modules = [],
            },
            Windows = new WindowsInfo
            {
                BuildNumber = build,
                Architecture = Architecture.X64,
                DeviceKind = DeviceKind.Desktop,
                InstallDate = new DateTime(2024, 1, 1),
                LastBootTime = new DateTime(2024, 1, 1),
            },
            Firmware = FirmwareInfo.Unknown,
            Security = SecurityInfo.Unknown,
            Power = PowerInfo.Unknown,
            Gpus =
                gpuVendor == GpuVendor.Unknown
                    ? []
                    :
                    [
                        new GpuInfo
                        {
                            Name = "Test GPU",
                            DriverVersion = "1.0",
                            Vendor = gpuVendor,
                            VramMB = 8192,
                        },
                    ],
            Storage = StorageInfo.Unknown,
            Runtime = RuntimeInfo.Unknown,
        };

    #endregion

    #region ConditionResult

    [Fact]
    public void ConditionResult_Available_IsNotBlocking()
    {
        Assert.False(ConditionResult.Available.IsBlocking);
        Assert.Equal(ConditionState.Available, ConditionResult.Available.State);
    }

    [Fact]
    public void ConditionResult_Unsupported_IsBlocking()
    {
        var result = ConditionResult.Unsupported(() => "k.Title", () => "k.Description");
        Assert.True(result.IsBlocking);
    }

    [Fact]
    public void ConditionResult_Error_IsNotBlocking()
    {
        var result = ConditionResult.Error();
        Assert.False(result.IsBlocking);
        Assert.Equal(ConditionState.Error, result.State);
    }

    [Fact]
    public void ConditionResult_ResolvesLocalizedTitleAndDescription()
    {
        var result = ConditionResult.Unsupported(
            () => Translations.Condition_Windows11_Title,
            () => Translations.Condition_Windows11_Description
        );

        Assert.False(string.IsNullOrEmpty(result.Title));
        Assert.False(string.IsNullOrEmpty(result.Description));
    }

    #endregion

    #region OS conditions

    [Theory]
    [InlineData(22000)]
    [InlineData(22631)]
    [InlineData(26100)]
    public void Windows11Condition_Win11Builds_Available(int build)
    {
        var result = new Windows11Condition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void Windows11Condition_UnknownBuild_Unsupported()
    {
        // An unreadable build number never passes a version gate (fail closed),
        // while an entirely unknown snapshot still fails open (see evaluator test).
        var snapshot = Snapshot() with
        {
            Windows = new WindowsInfo(),
        };
        var result = new Windows11Condition().Evaluate(snapshot);
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Theory]
    [InlineData(10240)]
    [InlineData(19045)]
    public void Windows11Condition_Win10Builds_Unsupported(int build)
    {
        var result = new Windows11Condition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Theory]
    [InlineData(10240)]
    [InlineData(19045)]
    public void Windows10Condition_Win10Builds_Available(int build)
    {
        var result = new Windows10Condition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Theory]
    [InlineData(22000)]
    [InlineData(22631)]
    public void Windows10Condition_Win11Builds_Unsupported(int build)
    {
        var result = new Windows10Condition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Theory]
    [InlineData(26100)]
    [InlineData(26120)]
    public void Windows11_24H2OrGreaterCondition_24H2Builds_Available(int build)
    {
        var result = new Windows11_24H2OrGreaterCondition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Theory]
    [InlineData(22631)]
    [InlineData(22000)]
    [InlineData(19045)]
    public void Windows11_24H2OrGreaterCondition_OlderBuilds_Unsupported(int build)
    {
        var result = new Windows11_24H2OrGreaterCondition().Evaluate(Snapshot(build: build));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    #endregion

    #region Hardware conditions

    [Fact]
    public void AmdGpuCondition_AmdGpu_Available()
    {
        var result = new AmdGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Amd));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void AmdGpuCondition_NvidiaGpu_Unsupported()
    {
        var result = new AmdGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Nvidia));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void NvidiaGpuCondition_NvidiaGpu_Available()
    {
        var result = new NvidiaGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Nvidia));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void NvidiaGpuCondition_AmdGpu_Unsupported()
    {
        var result = new NvidiaGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Amd));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void IntelGpuCondition_IntelGpu_Available()
    {
        var result = new IntelGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Intel));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void IntelCpuCondition_IntelCpu_Available()
    {
        var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Intel));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void IntelCpuCondition_AmdCpu_Unsupported()
    {
        var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Amd));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void AmdCpuCondition_AmdCpu_Available()
    {
        var result = new AmdCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Amd));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void IntelCpuCondition_UnknownCpu_FailsOpenToError()
    {
        // An undetected CPU vendor means detection failed, which must never hide the
        // item: the result is non-blocking Error instead of Unsupported.
        var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Unknown));
        Assert.Equal(ConditionState.Error, result.State);
        Assert.False(result.IsBlocking);
    }

    [Fact]
    public void SixteenGbRamCondition_16Gb_Available()
    {
        var result = new SixteenGbRamCondition().Evaluate(Snapshot(ramGb: 16));
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void SixteenGbRamCondition_8Gb_Unsupported()
    {
        var result = new SixteenGbRamCondition().Evaluate(Snapshot(ramGb: 8));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void NvidiaGpuCondition_NoGpu_FailsOpenToError()
    {
        // A missing/undetected GPU list means detection failed, which must never hide
        // the item: the result is non-blocking Error instead of Unsupported.
        var result = new NvidiaGpuCondition().Evaluate(Snapshot());
        Assert.Equal(ConditionState.Error, result.State);
        Assert.False(result.IsBlocking);
    }

    #endregion

    #region Registry & Service conditions

    private static readonly Func<string> KTitle = () => "k.Title";
    private static readonly Func<string> KDescription = () => "k.Description";

    private sealed class ExistingKeyCondition : RegistryKeyExistsCondition
    {
        protected override RegistryItem RegistryItem =>
            new(@"HKCU\Software\Microsoft\Windows\CurrentVersion");

        protected override Func<string> Title => KTitle;
        protected override Func<string> Description => KDescription;
    }

    private sealed class MissingKeyCondition : RegistryKeyExistsCondition
    {
        protected override RegistryItem RegistryItem =>
            new(@"HKCU\Software\OptimizerDuck_DefinitelyMissing_Key");

        protected override Func<string> Title => KTitle;
        protected override Func<string> Description => KDescription;
    }

    private sealed class ExistingServiceCondition : ServiceExistsCondition
    {
        protected override string ServiceName => "RpcSs";
        protected override Func<string> Title => KTitle;
        protected override Func<string> Description => KDescription;
    }

    private sealed class MissingServiceCondition : ServiceExistsCondition
    {
        protected override string ServiceName => "OptimizerDuckDefinitelyMissingService";
        protected override Func<string> Title => KTitle;
        protected override Func<string> Description => KDescription;
    }

    [Fact]
    public void RegistryKeyExistsCondition_ExistingKey_Available()
    {
        var result = new ExistingKeyCondition().Evaluate(Snapshot());
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void RegistryKeyExistsCondition_MissingKey_Unsupported()
    {
        var result = new MissingKeyCondition().Evaluate(Snapshot());
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void ServiceExistsCondition_ExistingService_Available()
    {
        var result = new ExistingServiceCondition().Evaluate(Snapshot());
        Assert.Equal(ConditionState.Available, result.State);
    }

    [Fact]
    public void ServiceExistsCondition_MissingService_Unsupported()
    {
        var result = new MissingServiceCondition().Evaluate(Snapshot());
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    #endregion

    #region ConditionEvaluator

    private static ConditionResult Evaluate(Type? type, SystemInfo snapshot) =>
        ConditionEvaluator.Evaluate(type, snapshot, NullLogger.Instance);

    [Fact]
    public void ConditionEvaluator_NullType_ReturnsAvailable()
    {
        Assert.Equal(ConditionState.Available, Evaluate(null, Snapshot()).State);
    }

    [Fact]
    public void ConditionEvaluator_ValidType_ReturnsEvaluatedResult()
    {
        var result = Evaluate(typeof(Windows11Condition), Snapshot(build: 19045));
        Assert.Equal(ConditionState.Unsupported, result.State);
    }

    [Fact]
    public void ConditionEvaluator_UnknownSnapshot_FailOpenToAvailable()
    {
        // An unpopulated snapshot (detection not finished/failed) never hides an item.
        Assert.Equal(
            ConditionState.Available,
            Evaluate(typeof(Windows11Condition), SystemInfo.Unknown).State
        );
        Assert.Equal(
            ConditionState.Available,
            Evaluate(typeof(Windows11_24H2OrGreaterCondition), SystemInfo.Unknown).State
        );
        Assert.Equal(
            ConditionState.Available,
            Evaluate(typeof(NvidiaGpuCondition), SystemInfo.Unknown).State
        );
        Assert.Equal(
            ConditionState.Available,
            Evaluate(typeof(SixteenGbRamCondition), SystemInfo.Unknown).State
        );
        Assert.Equal(
            ConditionState.Available,
            Evaluate(typeof(IntelCpuCondition), SystemInfo.Unknown).State
        );
    }

    [Fact]
    public void ConditionEvaluator_InvalidType_ReturnsError()
    {
        var result = Evaluate(typeof(string), Snapshot());
        Assert.Equal(ConditionState.Error, result.State);
    }

    [Fact]
    public void ConditionEvaluator_ThrowingCondition_ReturnsError()
    {
        var result = Evaluate(typeof(ThrowingCondition), Snapshot());
        Assert.Equal(ConditionState.Error, result.State);
    }

    [Fact]
    public void ConditionEvaluator_EvaluateAll_AppliesEveryResult()
    {
        var items = new[] { typeof(Windows11Condition), (Type?)null };
        var applied = new List<ConditionResult>();

        ConditionEvaluator.EvaluateAll(
            items,
            t => t,
            (t, r) => applied.Add(r),
            Snapshot(build: 19045),
            NullLogger.Instance
        );

        Assert.Equal(2, applied.Count);
        Assert.Equal(ConditionState.Unsupported, applied[0].State);
        Assert.Equal(ConditionState.Available, applied[1].State);
    }

    private sealed class ThrowingCondition : ConditionBase
    {
        public override ConditionResult Evaluate(SystemInfo snapshot)
        {
            throw new InvalidOperationException("boom");
        }
    }

    #endregion

    #region BaseOptimization condition blocking

    [Fact]
    public void BaseOptimization_UnsupportedAndNotApplied_IsBlocked()
    {
        var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
        Assert.True(optimization.IsConditionBlocked);
    }

    [Fact]
    public void BaseOptimization_UnsupportedAndApplied_IsNotBlocked()
    {
        var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
        optimization.State.IsApplied = true;
        Assert.False(optimization.IsConditionBlocked);
    }

    [Fact]
    public void BaseOptimization_UnsupportedAndHidden_IsNotBlocked()
    {
        var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
        optimization.IsConditionHidden = true;
        Assert.False(optimization.IsConditionBlocked);
    }

    [Fact]
    public void BaseOptimization_Available_IsNotBlocked()
    {
        var optimization = new ConditionedOptimization { Condition = ConditionState.Available };
        Assert.False(optimization.IsConditionBlocked);
    }

    [Fact]
    public void BaseOptimization_ConditionType_ReadFromAttribute()
    {
        var optimization = new ConditionedOptimization();
        Assert.Equal(typeof(Windows11Condition), optimization.ConditionType);
    }

    #endregion

    [Optimization(
        Id = "00000000-0000-0000-0000-000000000001",
        Risk = OptimizationRisk.Safe,
        Tags = OptimizationTags.System,
        Condition = typeof(Windows11Condition)
    )]
    private sealed class ConditionedOptimization : BaseOptimization
    {
        public ConditionState Condition
        {
            get => ConditionResult.State;
            set =>
                ConditionResult =
                    value == ConditionState.Available
                        ? ConditionResult.Available
                        : ConditionResult.Unsupported(() => "k.Title", () => "k.Description");
        }

        public override Task<ApplyResult> ApplyAsync(
            IProgress<ProcessingProgress> progress,
            OptimizationContext context
        ) => Task.FromResult(ApplyResult.True());
    }
}