< Summary

Information
Class: RoleRadar.Domain.Tracking.Criterion
Assembly: RoleRadar.Domain
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Tracking/Criterion.cs
Line coverage
98%
Covered lines: 82
Uncovered lines: 1
Coverable lines: 83
Total lines: 158
Line coverage: 98.7%
Branch coverage
90%
Covered branches: 20
Total branches: 22
Branch coverage: 90.9%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_Id()100%11100%
get_OwnerId()100%11100%
get_Key()100%11100%
get_Category()100%11100%
get_Value()100%11100%
get_EffectiveFrom()100%11100%
get_EffectiveTo()100%11100%
get_Provenance()100%11100%
get_IsActive()100%11100%
get_VersionToken()100%11100%
get_CreatedAt()100%11100%
.ctor()100%11100%
Create(...)80%1010100%
Rehydrate(...)100%22100%
Supersede(...)75%4496%
Deactivate(...)100%11100%
IsEffectiveAt(...)100%66100%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Tracking/Criterion.cs

#LineLine coverage
 1namespace RoleRadar.Domain.Tracking;
 2
 3public sealed class Criterion
 4{
 5    public const int MaxKeyLength = 100;
 6    public const int MaxValueLength = 500;
 7
 9548    public Guid Id { get; private set; }
 8129    public string OwnerId { get; private set; } = string.Empty;
 89810    public string Key { get; private set; } = string.Empty;
 55411    public CriterionCategory Category { get; private set; }
 82212    public string Value { get; private set; } = string.Empty;
 45613    public DateTimeOffset EffectiveFrom { get; private set; }
 61414    public DateTimeOffset? EffectiveTo { get; private set; }
 56015    public ProvenanceKind Provenance { get; private set; }
 43816    public bool IsActive { get; private set; }
 68817    public Guid VersionToken { get; private set; }
 40618    public DateTimeOffset CreatedAt { get; private set; }
 19
 52420    private Criterion() { }
 21
 22    public static Criterion Create(
 23        string ownerId,
 24        string key,
 25        CriterionCategory category,
 26        string value,
 27        ProvenanceKind provenance,
 28        DateTimeOffset effectiveFrom,
 29        Guid? id = null,
 30        Guid? versionToken = null,
 31        DateTimeOffset? createdAt = null)
 32    {
 17033        ArgumentException.ThrowIfNullOrWhiteSpace(ownerId);
 16834        ArgumentException.ThrowIfNullOrWhiteSpace(key);
 16835        ArgumentException.ThrowIfNullOrWhiteSpace(value);
 36
 16837        if (key.Trim().Length > MaxKeyLength)
 38        {
 239            throw new ArgumentException($"Criterion key must not exceed {MaxKeyLength} characters.", nameof(key));
 40        }
 41
 16642        if (value.Trim().Length > MaxValueLength)
 43        {
 244            throw new ArgumentException($"Criterion value must not exceed {MaxValueLength} characters.", nameof(value));
 45        }
 46
 16447        var now = createdAt ?? DateTimeOffset.UtcNow;
 16448        return new Criterion
 16449        {
 16450            Id = id ?? Guid.CreateVersion7(),
 16451            OwnerId = ownerId.Trim(),
 16452            Key = key.Trim(),
 16453            Category = category,
 16454            Value = value.Trim(),
 16455            Provenance = provenance,
 16456            EffectiveFrom = effectiveFrom.ToUniversalTime(),
 16457            EffectiveTo = null,
 16458            IsActive = true,
 16459            VersionToken = versionToken ?? Guid.NewGuid(),
 16460            CreatedAt = now.ToUniversalTime()
 16461        };
 62    }
 63
 64    public static Criterion Rehydrate(
 65        Guid id,
 66        string ownerId,
 67        string key,
 68        CriterionCategory category,
 69        string value,
 70        DateTimeOffset effectiveFrom,
 71        DateTimeOffset? effectiveTo,
 72        ProvenanceKind provenance,
 73        bool isActive,
 74        Guid versionToken,
 75        DateTimeOffset createdAt)
 76    {
 8677        return new Criterion
 8678        {
 8679            Id = id,
 8680            OwnerId = ownerId,
 8681            Key = key,
 8682            Category = category,
 8683            Value = value,
 8684            EffectiveFrom = effectiveFrom.ToUniversalTime(),
 8685            EffectiveTo = effectiveTo?.ToUniversalTime(),
 8686            Provenance = provenance,
 8687            IsActive = isActive,
 8688            VersionToken = versionToken,
 8689            CreatedAt = createdAt.ToUniversalTime()
 8690        };
 91    }
 92
 93    public Criterion Supersede(
 94        CriterionCategory newCategory,
 95        string newValue,
 96        ProvenanceKind newProvenance,
 97        DateTimeOffset newEffectiveFrom,
 98        DateTimeOffset now)
 99    {
 18100        ArgumentException.ThrowIfNullOrWhiteSpace(newValue);
 18101        if (newValue.Trim().Length > MaxValueLength)
 102        {
 0103            throw new ArgumentException($"Criterion value must not exceed {MaxValueLength} characters.", nameof(newValue
 104        }
 105
 18106        var utcNewEffectiveFrom = newEffectiveFrom.ToUniversalTime();
 18107        if (utcNewEffectiveFrom <= EffectiveFrom)
 108        {
 6109            throw new ArgumentException(
 6110                $"New effectiveFrom timestamp '{utcNewEffectiveFrom:O}' must be strictly later than current active versi
 6111                nameof(newEffectiveFrom));
 112        }
 113
 114        // Close current active version
 12115        IsActive = false;
 12116        EffectiveTo = utcNewEffectiveFrom;
 12117        VersionToken = Guid.NewGuid();
 118
 119        // Create replacement active version
 12120        return new Criterion
 12121        {
 12122            Id = Guid.CreateVersion7(),
 12123            OwnerId = OwnerId,
 12124            Key = Key,
 12125            Category = newCategory,
 12126            Value = newValue.Trim(),
 12127            Provenance = newProvenance,
 12128            EffectiveFrom = utcNewEffectiveFrom,
 12129            EffectiveTo = null,
 12130            IsActive = true,
 12131            VersionToken = Guid.NewGuid(),
 12132            CreatedAt = now.ToUniversalTime()
 12133        };
 134    }
 135
 136    public void Deactivate(DateTimeOffset deactivationDate)
 137    {
 10138        IsActive = false;
 10139        EffectiveTo = deactivationDate.ToUniversalTime();
 10140        VersionToken = Guid.NewGuid();
 10141    }
 142
 143    public bool IsEffectiveAt(DateTimeOffset date)
 144    {
 20145        var utc = date.ToUniversalTime();
 20146        if (utc < EffectiveFrom)
 147        {
 6148            return false;
 149        }
 150
 14151        if (EffectiveTo.HasValue && utc >= EffectiveTo.Value)
 152        {
 6153            return false;
 154        }
 155
 8156        return true;
 157    }
 158}