Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

13.3 KB
Raw Blame
//-----------------------------------------------------------------------
// <copyright file="RateLimitResolverTests.cs" company="aliasvault">
// Copyright (c) aliasvault. All rights reserved.
// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
// </copyright>
//-----------------------------------------------------------------------

namespace AliasVault.UnitTests.Services.RateLimiting;

using AliasServerDb;
using AliasVault.Api.Services.RateLimiting;
using AliasVault.Api.Services.RateLimiting.Helpers;
using AliasVault.Api.Services.RateLimiting.Models;

/// <summary>
/// Tests for <see cref="RateLimitResolver"/> with various rule combinations.
/// </summary>
public class RateLimitResolverTests
{
    private const int Day = 86400;
    private const int Week = 604800;
    private static readonly Guid GroupId = new("11111111-1111-1111-1111-111111111111");
    private static readonly Guid OtherGroupId = new("22222222-2222-2222-2222-222222222222");
    private static readonly DateTime Now = new(2026, 1, 1, 12, 0, 0, DateTimeKind.Utc);

    /// <summary>
    /// With no rules and no legacy caps, no limit applies.
    /// </summary>
    [Test]
    public void NoRulesNoLegacyTest()
    {
        var result = Resolve([], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// A single global absolute cap applies to the group.
    /// </summary>
    [Test]
    public void GlobalAbsoluteCapTest()
    {
        var result = Resolve([Rule(window: 0, max: 20)], Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].WindowSeconds, Is.EqualTo(0));
            Assert.That(result[0].MaxCount, Is.EqualTo(20));
        });
    }

    /// <summary>
    /// A single global velocity window applies to the group.
    /// </summary>
    [Test]
    public void GlobalVelocityWindowTest()
    {
        var result = Resolve([Rule(window: Day, max: 10)], Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].WindowSeconds, Is.EqualTo(Day));
            Assert.That(result[0].MaxCount, Is.EqualTo(10));
        });
    }

    /// <summary>
    /// Absolute cap and multiple velocity windows are all returned and enforced together.
    /// </summary>
    [Test]
    public void MultipleWindowsAllAppliedTest()
    {
        var result = Resolve(
            [
                Rule(window: 0, max: 20),
                Rule(window: Day, max: 10),
                Rule(window: Week, max: 50),
            ],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(3));
            Assert.That(MaxFor(result, 0), Is.EqualTo(20));
            Assert.That(MaxFor(result, Day), Is.EqualTo(10));
            Assert.That(MaxFor(result, Week), Is.EqualTo(50));
        });
    }

    /// <summary>
    /// A per-group override replaces the global value for the same window, even when it raises the limit.
    /// </summary>
    [Test]
    public void PerGroupOverrideRaisesGlobalTest()
    {
        var result = Resolve(
            [
                Rule(window: 0, max: 20),
                Rule(window: 0, max: 500, groupId: GroupId),
            ],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].MaxCount, Is.EqualTo(500));
        });
    }

    /// <summary>
    /// A per-group override that lowers the global value is applied (temporary abuse clamp scenario).
    /// </summary>
    [Test]
    public void PerGroupOverrideLowersGlobalTest()
    {
        var result = Resolve(
            [
                Rule(window: Day, max: 50),
                Rule(window: Day, max: 5, groupId: GroupId),
            ],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].MaxCount, Is.EqualTo(5));
        });
    }

    /// <summary>
    /// A per-group override with MaxCount 0 (unlimited) lifts a stricter global limit for that group.
    /// </summary>
    [Test]
    public void PerGroupUnlimitedLiftsGlobalTest()
    {
        var result = Resolve(
            [
                Rule(window: Day, max: 10),
                Rule(window: Day, max: 0, groupId: GroupId),
            ],
            Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// A per-group override only applies to the targeted group; a different group still gets the global value.
    /// </summary>
    [Test]
    public void PerGroupOverrideDoesNotLeakToOtherGroupTest()
    {
        RateLimit[] rules =
        [
            Rule(window: 0, max: 20),
            Rule(window: 0, max: 500, groupId: GroupId),
        ];

        var other = Resolve(rules, Group(OtherGroupId));

        Assert.Multiple(() =>
        {
            Assert.That(other, Has.Count.EqualTo(1));
            Assert.That(other[0].MaxCount, Is.EqualTo(20));
        });
    }

    /// <summary>
    /// A tier rule for the group's tier (Free) applies, while a tier rule for another tier (Premium) is ignored.
    /// </summary>
    [Test]
    public void TierRuleAppliesOnlyForMatchingTierTest()
    {
        var freeResult = Resolve([Rule(window: 0, max: 20, tier: AccountTier.Free)], Group(GroupId));
        var premiumResult = Resolve([Rule(window: 0, max: 100, tier: AccountTier.Premium)], Group(GroupId));

        Assert.Multiple(() =>
        {
            // The group resolves to Free, so the Free tier rule applies.
            Assert.That(freeResult, Has.Count.EqualTo(1));
            Assert.That(freeResult[0].MaxCount, Is.EqualTo(20));

            // The Premium tier rule does not apply to a Free group (tiers are not implemented yet).
            Assert.That(premiumResult, Is.Empty);
        });
    }

    /// <summary>
    /// Precedence for a single window: per-group override beats tier default beats global default.
    /// </summary>
    [Test]
    public void ScopePrecedenceGroupBeatsTierBeatsGlobalTest()
    {
        RateLimit[] rules =
        [
            Rule(window: 0, max: 20),
            Rule(window: 0, max: 100, tier: AccountTier.Free),
            Rule(window: 0, max: 500, groupId: GroupId),
        ];

        // Group rule wins when present.
        var withGroupRule = Resolve(rules, Group(GroupId));

        // Tier rule wins for a different group (no group rule), over the global default.
        var withoutGroupRule = Resolve(rules, Group(OtherGroupId));

        Assert.Multiple(() =>
        {
            Assert.That(withGroupRule[0].MaxCount, Is.EqualTo(500));
            Assert.That(withoutGroupRule[0].MaxCount, Is.EqualTo(100));
        });
    }

    /// <summary>
    /// Disabled rules are ignored.
    /// </summary>
    [Test]
    public void DisabledRuleIgnoredTest()
    {
        var result = Resolve([Rule(window: 0, max: 20, enabled: false)], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// Rules of a different limit type are ignored.
    /// </summary>
    [Test]
    public void DifferentLimitTypeIgnoredTest()
    {
        // Only AliasCreation exists today; use an out-of-range cast value to represent a different type so the
        // filter is exercised without depending on a second enum member being added later.
        var otherType = (RateLimitType)999;
        var result = Resolve([Rule(window: 0, max: 20, type: otherType)], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// A rule with EffectiveFrom in the future is not yet active.
    /// </summary>
    [Test]
    public void EffectiveFromInFutureNotActiveTest()
    {
        var result = Resolve([Rule(window: 0, max: 20, from: Now.AddHours(1))], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// A rule with EffectiveUntil in the past has expired.
    /// </summary>
    [Test]
    public void EffectiveUntilInPastExpiredTest()
    {
        var result = Resolve([Rule(window: 0, max: 20, until: Now.AddHours(-1))], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// A rule whose effective window brackets the current time is active.
    /// </summary>
    [Test]
    public void EffectiveWindowActiveTest()
    {
        var result = Resolve(
            [Rule(window: 0, max: 20, from: Now.AddHours(-1), until: Now.AddHours(1))],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].MaxCount, Is.EqualTo(20));
        });
    }

    /// <summary>
    /// Within the same scope+window, the most restrictive concrete limit wins.
    /// </summary>
    [Test]
    public void SameScopeMostRestrictiveWinsTest()
    {
        var result = Resolve(
            [
                Rule(window: Day, max: 50),
                Rule(window: Day, max: 10),
            ],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].MaxCount, Is.EqualTo(10));
        });
    }

    /// <summary>
    /// Within the same scope+window, a concrete limit wins over an "unlimited" (0) rule regardless of order.
    /// </summary>
    [Test]
    public void SameScopeConcreteBeatsUnlimitedTest()
    {
        var unlimitedFirst = Resolve(
            [
                Rule(window: Day, max: 0),
                Rule(window: Day, max: 10),
            ],
            Group(GroupId));

        var concreteFirst = Resolve(
            [
                Rule(window: Day, max: 10),
                Rule(window: Day, max: 0),
            ],
            Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(unlimitedFirst, Has.Count.EqualTo(1));
            Assert.That(unlimitedFirst[0].MaxCount, Is.EqualTo(10));
            Assert.That(concreteFirst, Has.Count.EqualTo(1));
            Assert.That(concreteFirst[0].MaxCount, Is.EqualTo(10));
        });
    }

    /// <summary>
    /// A standalone global "unlimited" (0) rule produces no enforced limit.
    /// </summary>
    [Test]
    public void GlobalUnlimitedProducesNoLimitTest()
    {
        var result = Resolve([Rule(window: 0, max: 0)], Group(GroupId));

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// An age-gated rule applies to an account younger than the configured age (new-account cap).
    /// </summary>
    [Test]
    public void AgeGatedRuleAppliesToNewAccountTest()
    {
        var newGroup = Group(GroupId, createdAt: Now.AddDays(-1));
        var result = Resolve([Rule(window: 0, max: 5, ageMaxDays: 7)], newGroup);

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(1));
            Assert.That(result[0].MaxCount, Is.EqualTo(5));
        });
    }

    /// <summary>
    /// An age-gated rule is ignored once the account is older than the configured age.
    /// </summary>
    [Test]
    public void AgeGatedRuleIgnoredForOldAccountTest()
    {
        var oldGroup = Group(GroupId, createdAt: Now.AddDays(-30));
        var result = Resolve([Rule(window: 0, max: 5, ageMaxDays: 7)], oldGroup);

        Assert.That(result, Is.Empty);
    }

    /// <summary>
    /// Full combined scenario: free default absolute cap, premium tier cap (ignored for a free group), a per-group
    /// absolute override that raises the cap, plus a global daily velocity window. The group gets the override
    /// absolute cap and the daily window.
    /// </summary>
    [Test]
    public void CombinedScenarioTest()
    {
        RateLimit[] rules =
        [
            Rule(window: 0, max: 20),
            Rule(window: 0, max: 100, tier: AccountTier.Premium),
            Rule(window: 0, max: 500, groupId: GroupId),
            Rule(window: Day, max: 10),
        ];

        var result = Resolve(rules, Group(GroupId));

        Assert.Multiple(() =>
        {
            Assert.That(result, Has.Count.EqualTo(2));
            Assert.That(MaxFor(result, 0), Is.EqualTo(500));
            Assert.That(MaxFor(result, Day), Is.EqualTo(10));
        });
    }

    private static IReadOnlyList<EffectiveRateLimit> Resolve(
        RateLimit[] rules,
        Group group)
        => RateLimitResolver.Resolve(rules, group, RateLimitType.AliasCreation, Now);

    private static int MaxFor(IReadOnlyList<EffectiveRateLimit> result, int window)
        => result.Single(r => r.WindowSeconds == window).MaxCount;

    private static Group Group(Guid id, DateTime? createdAt = null)
        => new() { Id = id, Name = "group", CreatedAt = createdAt ?? Now };

    private static RateLimit Rule(
        int window,
        int max,
        Guid? groupId = null,
        AccountTier? tier = null,
        bool enabled = true,
        RateLimitType type = RateLimitType.AliasCreation,
        DateTime? from = null,
        DateTime? until = null,
        int? ageMaxDays = null)
        => new()
        {
            Id = Guid.NewGuid(),
            LimitType = type,
            GroupId = groupId,
            Tier = tier,
            WindowSeconds = window,
            MaxCount = max,
            Enabled = enabled,
            EffectiveFrom = from,
            EffectiveUntil = until,
            AppliesToAccountAgeMaxDays = ageMaxDays,
        };
}