feat(trust-lattice): complete Sprint 7100 VEX Trust Lattice implementation
Sprint 7100 - VEX Trust Lattice for Explainable, Replayable Decisioning Completed all 6 sprints (54 tasks): - 7100.0001.0001: Trust Vector Foundation (TrustVector P/C/R, ClaimScoreCalculator) - 7100.0001.0002: Verdict Manifest & Replay (VerdictManifest, DSSE signing) - 7100.0002.0001: Policy Gates & Merge (MinimumConfidence, SourceQuota, UnknownsBudget) - 7100.0002.0002: Source Defaults & Calibration (DefaultTrustVectors, TrustCalibrationService) - 7100.0003.0001: UI Trust Algebra Panel (Angular components with WCAG 2.1 AA accessibility) - 7100.0003.0002: Integration & Documentation (specs, schemas, E2E tests, training docs) Key deliverables: - Trust vector model with P/C/R components and configurable weights - Claim scoring: ClaimScore = BaseTrust(S) * M * F - Policy gates for minimum confidence, source quotas, reachability requirements - Verdict manifests with DSSE signing and deterministic replay - Angular Trust Algebra UI with accessibility improvements - Comprehensive E2E integration tests (9 scenarios) - Full documentation and training materials 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
StellaOps Bot
@@ -0,0 +1,43 @@
|
||||
<?xml version='1.0' encoding='utf-8'?>
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<LangVersion>preview</LangVersion>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<IsPackable>false</IsPackable>
|
||||
<IsTestProject>true</IsTestProject>
|
||||
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
|
||||
<PackageReference Include="xunit" Version="2.9.3" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="coverlet.collector" Version="6.0.4">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="FluentAssertions" Version="8.2.0" />
|
||||
<PackageReference Include="Moq" Version="4.20.72" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<!-- Excititor: Trust vectors, claim scoring, calibration -->
|
||||
<ProjectReference Include="../../__Libraries/StellaOps.Scanner.Core/StellaOps.Scanner.Core.csproj" />
|
||||
<ProjectReference Include="../../../Excititor/__Libraries/StellaOps.Excititor.Core/StellaOps.Excititor.Core.csproj" />
|
||||
|
||||
<!-- Policy: Gates, merge, trust lattice engine -->
|
||||
<ProjectReference Include="../../../Policy/__Libraries/StellaOps.Policy/StellaOps.Policy.csproj" />
|
||||
|
||||
<!-- Authority: Verdict manifests, signing, replay -->
|
||||
<ProjectReference Include="../../../Authority/__Libraries/StellaOps.Authority.Core/StellaOps.Authority.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<None Update="Fixtures\**\*" CopyToOutputDirectory="PreserveNewest" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,648 @@
|
||||
using System.Collections.Immutable;
|
||||
using FluentAssertions;
|
||||
using StellaOps.Authority.Core.Verdicts;
|
||||
using StellaOps.Excititor.Core;
|
||||
using StellaOps.Policy.Gates;
|
||||
using Xunit;
|
||||
|
||||
// Disambiguate types that exist in both Excititor.Core and Policy.TrustLattice
|
||||
using VexStatus = StellaOps.Policy.Confidence.Models.VexStatus;
|
||||
using ClaimScoreResult = StellaOps.Policy.TrustLattice.ClaimScoreResult;
|
||||
using MergeResult = StellaOps.Policy.TrustLattice.MergeResult;
|
||||
using ScoredClaim = StellaOps.Policy.TrustLattice.ScoredClaim;
|
||||
using ClaimScoreMerger = StellaOps.Policy.TrustLattice.ClaimScoreMerger;
|
||||
using MergePolicy = StellaOps.Policy.TrustLattice.MergePolicy;
|
||||
using VexClaim = StellaOps.Policy.TrustLattice.VexClaim;
|
||||
using ConflictRecord = StellaOps.Policy.TrustLattice.ConflictRecord;
|
||||
using AuthorityVexStatus = StellaOps.Authority.Core.Verdicts.VexStatus;
|
||||
|
||||
namespace StellaOps.Scanner.Integration.Tests.TrustLattice;
|
||||
|
||||
/// <summary>
|
||||
/// End-to-end integration tests for the Trust Lattice flow.
|
||||
/// Tests the full pipeline: VEX ingest -> score -> merge -> verdict -> sign -> replay
|
||||
/// </summary>
|
||||
public sealed class TrustLatticeE2ETests
|
||||
{
|
||||
private static readonly DateTimeOffset TestClock = DateTimeOffset.Parse("2025-01-15T12:00:00Z");
|
||||
private static readonly DateTimeOffset RecentClaim = DateTimeOffset.Parse("2025-01-10T00:00:00Z");
|
||||
private static readonly DateTimeOffset OldClaim = DateTimeOffset.Parse("2024-07-01T00:00:00Z");
|
||||
|
||||
#region Scenario 1: Single source, high confidence -> PASS
|
||||
|
||||
[Fact]
|
||||
public async Task SingleSource_HighConfidence_ShouldPass()
|
||||
{
|
||||
// Arrange: Single vendor VEX claim with high trust score
|
||||
var merger = new ClaimScoreMerger();
|
||||
var gates = CreatePolicyGates();
|
||||
|
||||
// Simulate high-confidence vendor claim (pre-scored)
|
||||
var claim = new VexClaim
|
||||
{
|
||||
SourceId = "vendor:acme",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 3,
|
||||
IssuedAt = RecentClaim,
|
||||
};
|
||||
var score = CreateScore(0.85, 0.82, 0.90, 0.95);
|
||||
|
||||
// Merge (single claim)
|
||||
var mergeResult = merger.Merge(
|
||||
new List<(VexClaim, ClaimScoreResult)> { (claim, score) },
|
||||
new MergePolicy());
|
||||
|
||||
// Evaluate gates
|
||||
var context = new PolicyGateContext { Environment = "production" };
|
||||
var gateResults = await EvaluateAllGatesAsync(gates, mergeResult, context);
|
||||
|
||||
// Assert
|
||||
mergeResult.Confidence.Should().BeGreaterThan(0.75);
|
||||
mergeResult.HasConflicts.Should().BeFalse();
|
||||
gateResults.Should().OnlyContain(r => r.Passed, "all gates should pass for high-confidence single source");
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 2: Multiple agreeing sources -> PASS with merged confidence
|
||||
|
||||
[Fact]
|
||||
public async Task MultipleAgreeingSources_ShouldPass()
|
||||
{
|
||||
// Arrange: Multiple sources agreeing on NotAffected
|
||||
var merger = new ClaimScoreMerger();
|
||||
var gates = CreatePolicyGates();
|
||||
|
||||
var claims = new List<(VexClaim, ClaimScoreResult)>
|
||||
{
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "vendor:acme",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 2,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.80, 0.78, 0.80, 0.95)),
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "distro:debian",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 3,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.78, 0.76, 0.80, 0.95)),
|
||||
};
|
||||
|
||||
// Merge
|
||||
var mergeResult = merger.Merge(claims, new MergePolicy());
|
||||
|
||||
// Evaluate gates
|
||||
var context = new PolicyGateContext { Environment = "production" };
|
||||
var gateResults = await EvaluateAllGatesAsync(gates, mergeResult, context);
|
||||
|
||||
// Assert
|
||||
mergeResult.HasConflicts.Should().BeFalse("agreeing sources should not conflict");
|
||||
mergeResult.Status.Should().Be(VexStatus.NotAffected);
|
||||
gateResults.Should().OnlyContain(r => r.Passed);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 3: Conflicting sources -> Conflict penalty applied
|
||||
|
||||
[Fact]
|
||||
public void ConflictingSources_ShouldApplyConflictPenalty()
|
||||
{
|
||||
// Arrange: Two sources with opposing statuses
|
||||
var merger = new ClaimScoreMerger();
|
||||
|
||||
var claims = new List<(VexClaim, ClaimScoreResult)>
|
||||
{
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "vendor:acme",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 2,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.80, 0.78, 0.80, 0.95)),
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "hub:osv",
|
||||
Status = VexStatus.Affected,
|
||||
ScopeSpecificity = 1,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.65, 0.60, 0.70, 0.90)),
|
||||
};
|
||||
|
||||
// Merge with conflict penalty
|
||||
var mergePolicy = new MergePolicy { ConflictPenalty = 0.25 };
|
||||
var mergeResult = merger.Merge(claims, mergePolicy);
|
||||
|
||||
// Assert
|
||||
mergeResult.HasConflicts.Should().BeTrue("opposing statuses should create conflict");
|
||||
mergeResult.Conflicts.Should().NotBeEmpty();
|
||||
mergeResult.RequiresReplayProof.Should().BeTrue("conflicts require replay proof");
|
||||
|
||||
// Higher-trust source (vendor) should win
|
||||
mergeResult.WinningClaim.SourceId.Should().Be("vendor:acme");
|
||||
mergeResult.Status.Should().Be(VexStatus.NotAffected);
|
||||
|
||||
// Loser should have penalty applied
|
||||
var losingClaim = mergeResult.AllClaims.First(c => c.SourceId == "hub:osv");
|
||||
losingClaim.AdjustedScore.Should().BeLessThan(losingClaim.OriginalScore);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 4: Below minimum confidence -> FAIL gate
|
||||
|
||||
[Fact]
|
||||
public async Task BelowMinimumConfidence_ShouldFailGate()
|
||||
{
|
||||
// Arrange: Low-confidence claim
|
||||
var merger = new ClaimScoreMerger();
|
||||
|
||||
var claim = new VexClaim
|
||||
{
|
||||
SourceId = "hub:community",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 1,
|
||||
IssuedAt = OldClaim,
|
||||
};
|
||||
// Low score due to low trust and old claim
|
||||
var score = CreateScore(0.35, 0.40, 0.50, 0.50);
|
||||
|
||||
var mergeResult = merger.Merge(
|
||||
new List<(VexClaim, ClaimScoreResult)> { (claim, score) },
|
||||
new MergePolicy());
|
||||
|
||||
// Evaluate MinimumConfidenceGate
|
||||
var context = new PolicyGateContext { Environment = "production" };
|
||||
var gate = new MinimumConfidenceGate();
|
||||
var result = await gate.EvaluateAsync(mergeResult, context);
|
||||
|
||||
// Assert
|
||||
mergeResult.Confidence.Should().BeLessThan(0.75, "low trust + old claim should have low confidence");
|
||||
result.Passed.Should().BeFalse();
|
||||
result.Reason.Should().Be("confidence_below_threshold");
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 5: Source quota exceeded -> FAIL gate (no corroboration)
|
||||
|
||||
[Fact]
|
||||
public async Task SourceQuotaExceeded_ShouldFailGate()
|
||||
{
|
||||
// Arrange: Single dominant source without corroboration
|
||||
var winner = new ScoredClaim
|
||||
{
|
||||
SourceId = "vendor:monopoly",
|
||||
Status = VexStatus.NotAffected,
|
||||
OriginalScore = 0.95,
|
||||
AdjustedScore = 0.95,
|
||||
ScopeSpecificity = 3,
|
||||
Accepted = true,
|
||||
Reason = "winner",
|
||||
};
|
||||
|
||||
var weak = new ScoredClaim
|
||||
{
|
||||
SourceId = "hub:weak",
|
||||
Status = VexStatus.NotAffected,
|
||||
OriginalScore = 0.05,
|
||||
AdjustedScore = 0.05,
|
||||
ScopeSpecificity = 1,
|
||||
Accepted = false,
|
||||
Reason = "low_score",
|
||||
};
|
||||
|
||||
var mergeResult = new MergeResult
|
||||
{
|
||||
Status = VexStatus.NotAffected,
|
||||
Confidence = 0.95,
|
||||
HasConflicts = false,
|
||||
RequiresReplayProof = false,
|
||||
WinningClaim = winner,
|
||||
AllClaims = ImmutableArray.Create(winner, weak),
|
||||
Conflicts = ImmutableArray<ConflictRecord>.Empty,
|
||||
};
|
||||
|
||||
// Evaluate SourceQuotaGate (requires corroboration within 10% delta)
|
||||
var gate = new SourceQuotaGate(new SourceQuotaGateOptions
|
||||
{
|
||||
MaxInfluencePercent = 60,
|
||||
CorroborationDelta = 0.10,
|
||||
});
|
||||
var result = await gate.EvaluateAsync(mergeResult, new PolicyGateContext());
|
||||
|
||||
// Assert
|
||||
result.Passed.Should().BeFalse("single source with >60% influence without corroboration should fail");
|
||||
result.Reason.Should().Be("source_quota_exceeded");
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 6: Critical CVE without reachability -> FAIL gate
|
||||
|
||||
[Fact]
|
||||
public async Task CriticalCveWithoutReachability_ShouldFailGate()
|
||||
{
|
||||
// Arrange: High-confidence NotAffected claim but critical severity without proof
|
||||
var mergeResult = CreateHighConfidenceMergeResult(VexStatus.NotAffected, 0.90);
|
||||
|
||||
var gate = new ReachabilityRequirementGate();
|
||||
var context = new PolicyGateContext
|
||||
{
|
||||
Severity = "CRITICAL",
|
||||
HasReachabilityProof = false,
|
||||
};
|
||||
|
||||
var result = await gate.EvaluateAsync(mergeResult, context);
|
||||
|
||||
// Assert
|
||||
result.Passed.Should().BeFalse("critical CVE without reachability proof should fail");
|
||||
result.Reason.Should().Be("reachability_proof_missing");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CriticalCveWithReachability_ShouldPassGate()
|
||||
{
|
||||
// Arrange: Same as above but with reachability proof
|
||||
var mergeResult = CreateHighConfidenceMergeResult(VexStatus.NotAffected, 0.90);
|
||||
|
||||
var gate = new ReachabilityRequirementGate();
|
||||
var context = new PolicyGateContext
|
||||
{
|
||||
Severity = "CRITICAL",
|
||||
HasReachabilityProof = true,
|
||||
};
|
||||
|
||||
var result = await gate.EvaluateAsync(mergeResult, context);
|
||||
|
||||
// Assert
|
||||
result.Passed.Should().BeTrue();
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 7 & 8: Verdict replay verification
|
||||
|
||||
[Fact]
|
||||
public void VerdictReplay_IdenticalInputs_ShouldSucceed()
|
||||
{
|
||||
// Arrange: Build a verdict manifest
|
||||
var clock = DateTimeOffset.Parse("2025-01-15T12:00:00Z");
|
||||
var inputClock = DateTimeOffset.Parse("2025-01-15T00:00:00Z");
|
||||
|
||||
var manifest = BuildVerdictManifest(clock, inputClock, VexStatus.NotAffected, 0.85);
|
||||
|
||||
// Rebuild with same inputs (simulating replay)
|
||||
var replayedManifest = BuildVerdictManifest(clock, inputClock, VexStatus.NotAffected, 0.85);
|
||||
|
||||
// Assert: Digests should match (deterministic)
|
||||
replayedManifest.ManifestDigest.Should().Be(manifest.ManifestDigest);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void VerdictReplay_ChangedInputs_ShouldProduceDifferentDigest()
|
||||
{
|
||||
// Arrange: Build original verdict
|
||||
var clock = DateTimeOffset.Parse("2025-01-15T12:00:00Z");
|
||||
var inputClock = DateTimeOffset.Parse("2025-01-15T00:00:00Z");
|
||||
|
||||
var originalManifest = BuildVerdictManifest(clock, inputClock, VexStatus.NotAffected, 0.85);
|
||||
|
||||
// Rebuild with different VEX document (simulating changed input)
|
||||
var changedManifest = new VerdictManifestBuilder(() => "manifest-1")
|
||||
.WithTenant("tenant-1")
|
||||
.WithAsset("sha256:asset123", "CVE-2025-1234")
|
||||
.WithInputs(
|
||||
sbomDigests: new[] { "sha256:sbom1" },
|
||||
vulnFeedSnapshotIds: new[] { "feed-1" },
|
||||
vexDocumentDigests: new[] { "sha256:vex1", "sha256:vex2-NEW" }, // Changed!
|
||||
clockCutoff: inputClock)
|
||||
.WithResult(
|
||||
status: VexStatus.NotAffected,
|
||||
confidence: 0.85,
|
||||
explanations: CreateExplanations())
|
||||
.WithPolicy("sha256:policy1", "1.0.0")
|
||||
.WithClock(clock)
|
||||
.Build();
|
||||
|
||||
// Assert: Digests should NOT match
|
||||
changedManifest.ManifestDigest.Should().NotBe(originalManifest.ManifestDigest);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Scenario 9: Calibration epoch adjustments
|
||||
|
||||
[Fact]
|
||||
public void CalibrationEpoch_ShouldAdjustTrustVector()
|
||||
{
|
||||
// Arrange: Initial trust vector and calibration config
|
||||
var initialVector = new Excititor.Core.TrustVector
|
||||
{
|
||||
Provenance = 0.80,
|
||||
Coverage = 0.75,
|
||||
Replayability = 0.60,
|
||||
};
|
||||
|
||||
var calibrator = new TrustVectorCalibrator
|
||||
{
|
||||
LearningRate = 0.02,
|
||||
MaxAdjustmentPerEpoch = 0.05,
|
||||
MinValue = 0.10,
|
||||
MaxValue = 1.00,
|
||||
};
|
||||
|
||||
// Simulate comparison result showing optimistic bias
|
||||
var comparisonResult = new ComparisonResult
|
||||
{
|
||||
SourceId = "vendor:test",
|
||||
Accuracy = 0.85,
|
||||
TotalPredictions = 100,
|
||||
CorrectPredictions = 85,
|
||||
FalsePositives = 5,
|
||||
FalseNegatives = 10,
|
||||
ConfidenceInterval = 0.07,
|
||||
DetectedBias = CalibrationBias.OptimisticBias,
|
||||
};
|
||||
|
||||
// Calibrate
|
||||
var calibratedVector = calibrator.Calibrate(initialVector, comparisonResult, comparisonResult.DetectedBias);
|
||||
|
||||
// Assert: Provenance should decrease due to optimistic bias
|
||||
calibratedVector.Provenance.Should().BeLessThan(initialVector.Provenance);
|
||||
|
||||
// Values should stay within bounds
|
||||
calibratedVector.Provenance.Should().BeGreaterThanOrEqualTo(0.10);
|
||||
calibratedVector.Provenance.Should().BeLessThanOrEqualTo(1.00);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CalibrationEpoch_HighAccuracy_ShouldNotAdjust()
|
||||
{
|
||||
// Arrange: High accuracy source shouldn't need adjustment
|
||||
var initialVector = new Excititor.Core.TrustVector
|
||||
{
|
||||
Provenance = 0.90,
|
||||
Coverage = 0.85,
|
||||
Replayability = 0.70,
|
||||
};
|
||||
|
||||
var calibrator = new TrustVectorCalibrator
|
||||
{
|
||||
LearningRate = 0.02,
|
||||
MaxAdjustmentPerEpoch = 0.05,
|
||||
};
|
||||
|
||||
var comparisonResult = new ComparisonResult
|
||||
{
|
||||
SourceId = "vendor:excellent",
|
||||
Accuracy = 0.98,
|
||||
TotalPredictions = 100,
|
||||
CorrectPredictions = 98,
|
||||
FalsePositives = 1,
|
||||
FalseNegatives = 1,
|
||||
ConfidenceInterval = 0.03,
|
||||
DetectedBias = CalibrationBias.None,
|
||||
};
|
||||
|
||||
// Calibrate - high accuracy (>= 0.95) should result in no adjustment
|
||||
var calibratedVector = calibrator.Calibrate(initialVector, comparisonResult, comparisonResult.DetectedBias);
|
||||
|
||||
// Assert: Should remain unchanged (above threshold)
|
||||
calibratedVector.Provenance.Should().Be(initialVector.Provenance);
|
||||
calibratedVector.Coverage.Should().Be(initialVector.Coverage);
|
||||
calibratedVector.Replayability.Should().Be(initialVector.Replayability);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Full Flow Integration Test
|
||||
|
||||
[Fact]
|
||||
public async Task FullFlow_MergeToVerdict_ShouldProduceDeterministicResult()
|
||||
{
|
||||
// This test validates the complete merge-to-verdict flow:
|
||||
// Scored claims -> Merge -> Gate evaluation -> Verdict manifest
|
||||
|
||||
var merger = new ClaimScoreMerger();
|
||||
var gates = CreatePolicyGates();
|
||||
|
||||
// Pre-scored claims (simulating Excititor scoring output)
|
||||
var claims = new List<(VexClaim, ClaimScoreResult)>
|
||||
{
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "vendor:acme",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 3,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.85, 0.82, 0.90, 0.95)),
|
||||
(new VexClaim
|
||||
{
|
||||
SourceId = "distro:debian",
|
||||
Status = VexStatus.NotAffected,
|
||||
ScopeSpecificity = 3,
|
||||
IssuedAt = RecentClaim,
|
||||
}, CreateScore(0.80, 0.78, 0.80, 0.95)),
|
||||
};
|
||||
|
||||
// Merge claims
|
||||
var mergeResult = merger.Merge(claims, new MergePolicy { ConflictPenalty = 0.25 });
|
||||
|
||||
// Evaluate gates
|
||||
var context = new PolicyGateContext
|
||||
{
|
||||
Environment = "production",
|
||||
Severity = "HIGH",
|
||||
HasReachabilityProof = true,
|
||||
};
|
||||
var gateResults = await EvaluateAllGatesAsync(gates, mergeResult, context);
|
||||
var allPassed = gateResults.All(r => r.Passed);
|
||||
|
||||
// Build verdict manifest
|
||||
var manifest = new VerdictManifestBuilder(() => "verd:tenant:asset:CVE-2025-1234:1705323600")
|
||||
.WithTenant("tenant-1")
|
||||
.WithAsset("sha256:asset123", "CVE-2025-1234")
|
||||
.WithInputs(
|
||||
sbomDigests: new[] { "sha256:sbom1" },
|
||||
vulnFeedSnapshotIds: new[] { "feed-snapshot-1" },
|
||||
vexDocumentDigests: new[] { "sha256:vex-vendor", "sha256:vex-distro" },
|
||||
clockCutoff: TestClock)
|
||||
.WithResult(
|
||||
status: mergeResult.Status,
|
||||
confidence: mergeResult.Confidence,
|
||||
explanations: mergeResult.AllClaims.Select(c => new VerdictExplanation
|
||||
{
|
||||
SourceId = c.SourceId,
|
||||
Reason = c.Reason,
|
||||
ProvenanceScore = 0.85,
|
||||
CoverageScore = 0.80,
|
||||
ReplayabilityScore = 0.70,
|
||||
StrengthMultiplier = 0.90,
|
||||
FreshnessMultiplier = 0.95,
|
||||
ClaimScore = c.AdjustedScore,
|
||||
AssertedStatus = c.Status,
|
||||
Accepted = c.Accepted,
|
||||
}))
|
||||
.WithPolicy("sha256:policy123", "1.0.0")
|
||||
.WithClock(TestClock)
|
||||
.Build();
|
||||
|
||||
// Verify replay determinism
|
||||
var replayManifest = new VerdictManifestBuilder(() => "verd:tenant:asset:CVE-2025-1234:1705323600")
|
||||
.WithTenant("tenant-1")
|
||||
.WithAsset("sha256:asset123", "CVE-2025-1234")
|
||||
.WithInputs(
|
||||
sbomDigests: new[] { "sha256:sbom1" },
|
||||
vulnFeedSnapshotIds: new[] { "feed-snapshot-1" },
|
||||
vexDocumentDigests: new[] { "sha256:vex-vendor", "sha256:vex-distro" },
|
||||
clockCutoff: TestClock)
|
||||
.WithResult(
|
||||
status: mergeResult.Status,
|
||||
confidence: mergeResult.Confidence,
|
||||
explanations: mergeResult.AllClaims.Select(c => new VerdictExplanation
|
||||
{
|
||||
SourceId = c.SourceId,
|
||||
Reason = c.Reason,
|
||||
ProvenanceScore = 0.85,
|
||||
CoverageScore = 0.80,
|
||||
ReplayabilityScore = 0.70,
|
||||
StrengthMultiplier = 0.90,
|
||||
FreshnessMultiplier = 0.95,
|
||||
ClaimScore = c.AdjustedScore,
|
||||
AssertedStatus = c.Status,
|
||||
Accepted = c.Accepted,
|
||||
}))
|
||||
.WithPolicy("sha256:policy123", "1.0.0")
|
||||
.WithClock(TestClock)
|
||||
.Build();
|
||||
|
||||
// Assertions
|
||||
mergeResult.Status.Should().Be(VexStatus.NotAffected);
|
||||
mergeResult.HasConflicts.Should().BeFalse();
|
||||
allPassed.Should().BeTrue("all gates should pass for corroborated high-confidence claims");
|
||||
manifest.ManifestDigest.Should().StartWith("sha256:");
|
||||
manifest.ManifestDigest.Should().Be(replayManifest.ManifestDigest, "replay should be deterministic");
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Helpers
|
||||
|
||||
private static ClaimScoreResult CreateScore(double score, double baseTrust, double strength, double freshness)
|
||||
{
|
||||
return new ClaimScoreResult
|
||||
{
|
||||
Score = score,
|
||||
BaseTrust = baseTrust,
|
||||
StrengthMultiplier = strength,
|
||||
FreshnessMultiplier = freshness,
|
||||
};
|
||||
}
|
||||
|
||||
private static List<IPolicyGate> CreatePolicyGates()
|
||||
{
|
||||
return new List<IPolicyGate>
|
||||
{
|
||||
new MinimumConfidenceGate(),
|
||||
new UnknownsBudgetGate(new UnknownsBudgetGateOptions { MaxUnknownCount = 5, MaxCumulativeUncertainty = 1.0 }),
|
||||
new SourceQuotaGate(new SourceQuotaGateOptions { MaxInfluencePercent = 80, CorroborationDelta = 0.15 }),
|
||||
new ReachabilityRequirementGate(),
|
||||
};
|
||||
}
|
||||
|
||||
private static async Task<List<GateResult>> EvaluateAllGatesAsync(
|
||||
List<IPolicyGate> gates,
|
||||
MergeResult mergeResult,
|
||||
PolicyGateContext context)
|
||||
{
|
||||
var results = new List<GateResult>();
|
||||
foreach (var gate in gates)
|
||||
{
|
||||
results.Add(await gate.EvaluateAsync(mergeResult, context));
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
private static MergeResult CreateHighConfidenceMergeResult(VexStatus status, double confidence)
|
||||
{
|
||||
var winner = new ScoredClaim
|
||||
{
|
||||
SourceId = "vendor:trusted",
|
||||
Status = status,
|
||||
OriginalScore = confidence,
|
||||
AdjustedScore = confidence,
|
||||
ScopeSpecificity = 3,
|
||||
Accepted = true,
|
||||
Reason = "winner",
|
||||
};
|
||||
|
||||
return new MergeResult
|
||||
{
|
||||
Status = status,
|
||||
Confidence = confidence,
|
||||
HasConflicts = false,
|
||||
RequiresReplayProof = false,
|
||||
WinningClaim = winner,
|
||||
AllClaims = ImmutableArray.Create(winner),
|
||||
Conflicts = ImmutableArray<ConflictRecord>.Empty,
|
||||
};
|
||||
}
|
||||
|
||||
private static VerdictManifest BuildVerdictManifest(
|
||||
DateTimeOffset clock,
|
||||
DateTimeOffset inputClock,
|
||||
VexStatus status,
|
||||
double confidence)
|
||||
{
|
||||
return new VerdictManifestBuilder(() => "manifest-1")
|
||||
.WithTenant("tenant-1")
|
||||
.WithAsset("sha256:asset123", "CVE-2025-1234")
|
||||
.WithInputs(
|
||||
sbomDigests: new[] { "sha256:sbom1" },
|
||||
vulnFeedSnapshotIds: new[] { "feed-1" },
|
||||
vexDocumentDigests: new[] { "sha256:vex1" },
|
||||
clockCutoff: inputClock)
|
||||
.WithResult(
|
||||
status: ToAuthorityStatus(status),
|
||||
confidence: confidence,
|
||||
explanations: CreateExplanations())
|
||||
.WithPolicy("sha256:policy1", "1.0.0")
|
||||
.WithClock(clock)
|
||||
.Build();
|
||||
}
|
||||
|
||||
private static AuthorityVexStatus ToAuthorityStatus(VexStatus status) => status switch
|
||||
{
|
||||
VexStatus.Affected => AuthorityVexStatus.Affected,
|
||||
VexStatus.NotAffected => AuthorityVexStatus.NotAffected,
|
||||
VexStatus.Fixed => AuthorityVexStatus.Fixed,
|
||||
VexStatus.UnderInvestigation => AuthorityVexStatus.UnderInvestigation,
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(status)),
|
||||
};
|
||||
|
||||
private static IEnumerable<VerdictExplanation> CreateExplanations()
|
||||
{
|
||||
return new[]
|
||||
{
|
||||
new VerdictExplanation
|
||||
{
|
||||
SourceId = "vendor:test",
|
||||
Reason = "Official VEX",
|
||||
ProvenanceScore = 0.90,
|
||||
CoverageScore = 0.85,
|
||||
ReplayabilityScore = 0.70,
|
||||
StrengthMultiplier = 0.90,
|
||||
FreshnessMultiplier = 0.95,
|
||||
ClaimScore = 0.85,
|
||||
AssertedStatus = AuthorityVexStatus.NotAffected,
|
||||
Accepted = true,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
@@ -16,7 +16,12 @@ import { getConfidenceBand, formatConfidence, ConfidenceBand } from './trust-alg
|
||||
standalone: true,
|
||||
imports: [CommonModule],
|
||||
template: `
|
||||
<div class="confidence-meter" [attr.aria-label]="ariaLabel()">
|
||||
<div class="confidence-meter" role="meter"
|
||||
[attr.aria-label]="ariaLabel()"
|
||||
[attr.aria-valuenow]="confidence()"
|
||||
[attr.aria-valuemin]="0"
|
||||
[attr.aria-valuemax]="1"
|
||||
[attr.aria-valuetext]="ariaLabel()">
|
||||
<div class="confidence-meter__header">
|
||||
<span class="confidence-meter__label">Confidence</span>
|
||||
<span class="confidence-meter__value" [class]="valueClass()">
|
||||
|
||||
@@ -67,7 +67,7 @@ type ReplayState = 'idle' | 'loading' | 'success' | 'failure';
|
||||
|
||||
<!-- Result panel -->
|
||||
@if (result()) {
|
||||
<div [class]="resultPanelClass()">
|
||||
<div [class]="resultPanelClass()" role="alert" aria-live="assertive">
|
||||
@if (isSuccess()) {
|
||||
<div class="replay-button__result-header replay-button__result-header--success">
|
||||
<span class="replay-button__result-icon">✓</span>
|
||||
|
||||
338
src/Web/StellaOps.Web/tests/e2e/trust-algebra.spec.ts
Normal file
338
src/Web/StellaOps.Web/tests/e2e/trust-algebra.spec.ts
Normal file
@@ -0,0 +1,338 @@
|
||||
import { test, expect, Page } from '@playwright/test';
|
||||
import AxeBuilder from '@axe-core/playwright';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
/**
|
||||
* Trust Algebra Panel E2E Tests
|
||||
*
|
||||
* Tests for the VEX Trust Lattice visualization components.
|
||||
* @see Sprint 7100.0003.0001 T9
|
||||
*/
|
||||
|
||||
const reportDir = path.join(process.cwd(), 'test-results');
|
||||
|
||||
// Mock verdict manifest for testing
|
||||
const mockVerdictManifest = {
|
||||
manifestId: 'verd:test:sha256:abc123:CVE-2025-12345:1734873600',
|
||||
tenant: 'test-tenant',
|
||||
assetDigest: 'sha256:abc123def456789012345678901234567890123456789012345678901234',
|
||||
vulnerabilityId: 'CVE-2025-12345',
|
||||
inputs: {
|
||||
vexDocumentDigests: ['sha256:aaa111', 'sha256:bbb222'],
|
||||
policyDigest: 'sha256:policy123',
|
||||
},
|
||||
result: {
|
||||
status: 'not_affected',
|
||||
confidence: 0.82,
|
||||
explanations: [
|
||||
{
|
||||
sourceId: 'vendor:redhat',
|
||||
assertedStatus: 'not_affected',
|
||||
reason: 'vulnerable_code_not_in_execute_path',
|
||||
provenanceScore: 0.90,
|
||||
coverageScore: 0.85,
|
||||
replayabilityScore: 0.60,
|
||||
strengthMultiplier: 0.80,
|
||||
freshnessMultiplier: 0.98,
|
||||
claimScore: 0.82,
|
||||
accepted: true,
|
||||
},
|
||||
{
|
||||
sourceId: 'hub:osv',
|
||||
assertedStatus: 'affected',
|
||||
reason: 'under_investigation',
|
||||
provenanceScore: 0.75,
|
||||
coverageScore: 0.70,
|
||||
replayabilityScore: 0.50,
|
||||
strengthMultiplier: 0.40,
|
||||
freshnessMultiplier: 0.95,
|
||||
claimScore: 0.45,
|
||||
accepted: false,
|
||||
},
|
||||
],
|
||||
},
|
||||
policyHash: 'sha256:policy123',
|
||||
latticeVersion: 'v1.2.0',
|
||||
evaluatedAt: '2025-12-22T10:00:00Z',
|
||||
manifestDigest: 'sha256:manifest789',
|
||||
};
|
||||
|
||||
async function writeReport(filename: string, data: unknown) {
|
||||
fs.mkdirSync(reportDir, { recursive: true });
|
||||
fs.writeFileSync(path.join(reportDir, filename), JSON.stringify(data, null, 2));
|
||||
}
|
||||
|
||||
test.describe('Trust Algebra Panel', () => {
|
||||
test.describe('Component Rendering', () => {
|
||||
test('should render confidence meter with correct value', async ({ page }) => {
|
||||
// Navigate to a page with trust algebra component
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
// Wait for the trust algebra panel
|
||||
const trustAlgebra = page.locator('st-trust-algebra');
|
||||
await expect(trustAlgebra).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check confidence meter
|
||||
const meter = page.locator('st-confidence-meter');
|
||||
await expect(meter).toBeVisible();
|
||||
|
||||
// Verify ARIA attributes
|
||||
const meterDiv = meter.locator('[role="meter"]');
|
||||
await expect(meterDiv).toHaveAttribute('aria-valuemin', '0');
|
||||
await expect(meterDiv).toHaveAttribute('aria-valuemax', '1');
|
||||
});
|
||||
|
||||
test('should render claim table with sortable columns', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const claimTable = page.locator('st-claim-table');
|
||||
await expect(claimTable).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check for sortable headers
|
||||
const sortableHeaders = claimTable.locator('th[tabindex="0"]');
|
||||
await expect(sortableHeaders).toHaveCount(6); // Source, Status, P, C, R, Score
|
||||
|
||||
// Verify ARIA sort attribute
|
||||
const scoreHeader = claimTable.locator('th:has-text("Score")');
|
||||
await expect(scoreHeader).toHaveAttribute('aria-sort', 'descending');
|
||||
});
|
||||
|
||||
test('should render policy chips with gate status', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const policyChips = page.locator('st-policy-chips');
|
||||
await expect(policyChips).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check for gate chips
|
||||
const chips = policyChips.locator('.policy-chips__chip');
|
||||
await expect(chips.first()).toBeVisible();
|
||||
});
|
||||
|
||||
test('should render trust vector bars', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const trustVectorBars = page.locator('st-trust-vector-bars');
|
||||
await expect(trustVectorBars).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check for P/C/R segments
|
||||
const segments = trustVectorBars.locator('.trust-vector-bars__segment');
|
||||
await expect(segments).toHaveCount(3);
|
||||
});
|
||||
});
|
||||
|
||||
test.describe('Keyboard Navigation', () => {
|
||||
test('should navigate sortable columns with keyboard', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const claimTable = page.locator('st-claim-table');
|
||||
await expect(claimTable).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Focus on first sortable header
|
||||
const sourceHeader = claimTable.locator('th:has-text("Source")');
|
||||
await sourceHeader.focus();
|
||||
await expect(sourceHeader).toBeFocused();
|
||||
|
||||
// Press Enter to sort
|
||||
await page.keyboard.press('Enter');
|
||||
|
||||
// Verify sort changed
|
||||
await expect(sourceHeader).toHaveAttribute('aria-sort', 'ascending');
|
||||
|
||||
// Press Enter again to reverse
|
||||
await page.keyboard.press('Enter');
|
||||
await expect(sourceHeader).toHaveAttribute('aria-sort', 'descending');
|
||||
|
||||
// Tab to next sortable header
|
||||
await page.keyboard.press('Tab');
|
||||
const statusHeader = claimTable.locator('th:has-text("Status")');
|
||||
await expect(statusHeader).toBeFocused();
|
||||
});
|
||||
|
||||
test('should toggle sections with keyboard', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const trustAlgebra = page.locator('st-trust-algebra');
|
||||
await expect(trustAlgebra).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Focus on section header
|
||||
const sectionHeader = trustAlgebra.locator('button:has-text("Trust Vector")');
|
||||
await sectionHeader.focus();
|
||||
await expect(sectionHeader).toBeFocused();
|
||||
|
||||
// Check initial state
|
||||
await expect(sectionHeader).toHaveAttribute('aria-expanded', 'false');
|
||||
|
||||
// Press Enter to expand
|
||||
await page.keyboard.press('Enter');
|
||||
await expect(sectionHeader).toHaveAttribute('aria-expanded', 'true');
|
||||
|
||||
// Press Space to collapse
|
||||
await page.keyboard.press('Space');
|
||||
await expect(sectionHeader).toHaveAttribute('aria-expanded', 'false');
|
||||
});
|
||||
});
|
||||
|
||||
test.describe('Replay Functionality', () => {
|
||||
test('should trigger replay verification', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const replayButton = page.locator('st-replay-button');
|
||||
await expect(replayButton).toBeVisible({ timeout: 10000 });
|
||||
|
||||
const reproduceBtn = replayButton.locator('button:has-text("Reproduce Verdict")');
|
||||
await expect(reproduceBtn).toBeVisible();
|
||||
|
||||
// Click to trigger replay
|
||||
await reproduceBtn.click();
|
||||
|
||||
// Should show loading state
|
||||
await expect(reproduceBtn).toHaveAttribute('aria-busy', 'true');
|
||||
|
||||
// Wait for result
|
||||
const resultPanel = replayButton.locator('[role="alert"]');
|
||||
await expect(resultPanel).toBeVisible({ timeout: 15000 });
|
||||
});
|
||||
|
||||
test('should copy manifest ID to clipboard', async ({ page, context }) => {
|
||||
// Grant clipboard permissions
|
||||
await context.grantPermissions(['clipboard-read', 'clipboard-write']);
|
||||
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const replayButton = page.locator('st-replay-button');
|
||||
await expect(replayButton).toBeVisible({ timeout: 10000 });
|
||||
|
||||
const copyBtn = replayButton.locator('button:has-text("Copy ID")');
|
||||
await copyBtn.click();
|
||||
|
||||
// Check for feedback
|
||||
const feedback = replayButton.locator('[role="status"]');
|
||||
await expect(feedback).toContainText('copied');
|
||||
});
|
||||
});
|
||||
|
||||
test.describe('Accessibility', () => {
|
||||
test('should pass WCAG 2.1 AA checks', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
// Wait for trust algebra to load
|
||||
await page.locator('st-trust-algebra').waitFor({ state: 'visible', timeout: 10000 });
|
||||
|
||||
// Run axe accessibility checks
|
||||
const results = await new AxeBuilder({ page })
|
||||
.include('st-trust-algebra')
|
||||
.withTags(['wcag2a', 'wcag2aa'])
|
||||
.analyze();
|
||||
|
||||
const violations = results.violations.filter(
|
||||
(v) => !['color-contrast'].includes(v.id) // Exclude known issues
|
||||
);
|
||||
|
||||
await writeReport('a11y-trust-algebra.json', {
|
||||
url: page.url(),
|
||||
violations,
|
||||
});
|
||||
|
||||
expect(violations).toEqual([]);
|
||||
});
|
||||
|
||||
test('should have proper focus indicators', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const claimTable = page.locator('st-claim-table');
|
||||
await expect(claimTable).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Focus on sortable header
|
||||
const header = claimTable.locator('th:has-text("Source")');
|
||||
await header.focus();
|
||||
|
||||
// Check for visible focus indicator (outline)
|
||||
const outline = await header.evaluate((el) => {
|
||||
const styles = window.getComputedStyle(el);
|
||||
return styles.outline || styles.outlineWidth;
|
||||
});
|
||||
|
||||
expect(outline).not.toBe('none');
|
||||
expect(outline).not.toBe('0px');
|
||||
});
|
||||
|
||||
test('should announce live region updates', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const replayButton = page.locator('st-replay-button');
|
||||
await expect(replayButton).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check for aria-live region
|
||||
const liveRegion = replayButton.locator('[aria-live]');
|
||||
await expect(liveRegion).toBeVisible();
|
||||
|
||||
const ariaLive = await liveRegion.getAttribute('aria-live');
|
||||
expect(['polite', 'assertive']).toContain(ariaLive);
|
||||
});
|
||||
});
|
||||
|
||||
test.describe('Responsive Design', () => {
|
||||
test('should display correctly on mobile viewport', async ({ page }) => {
|
||||
await page.setViewportSize({ width: 375, height: 667 });
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const trustAlgebra = page.locator('st-trust-algebra');
|
||||
await expect(trustAlgebra).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Table should be scrollable
|
||||
const tableContainer = page.locator('.claim-table__container');
|
||||
const overflow = await tableContainer.evaluate((el) => {
|
||||
return window.getComputedStyle(el).overflowX;
|
||||
});
|
||||
|
||||
expect(['auto', 'scroll']).toContain(overflow);
|
||||
});
|
||||
|
||||
test('should display correctly on tablet viewport', async ({ page }) => {
|
||||
await page.setViewportSize({ width: 768, height: 1024 });
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const trustAlgebra = page.locator('st-trust-algebra');
|
||||
await expect(trustAlgebra).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// All sections should be visible
|
||||
const sections = trustAlgebra.locator('.trust-algebra__section');
|
||||
await expect(sections).toHaveCount(4); // Confidence, Trust Vector, Claims, Policy
|
||||
});
|
||||
});
|
||||
|
||||
test.describe('Conflict Handling', () => {
|
||||
test('should highlight conflicting claims', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const claimTable = page.locator('st-claim-table');
|
||||
await expect(claimTable).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Check for conflict indicators
|
||||
const conflictRows = claimTable.locator('.claim-table__row--conflict');
|
||||
const winnerRows = claimTable.locator('.claim-table__row--winner');
|
||||
|
||||
// Should have at least one winner and one conflict
|
||||
await expect(winnerRows).toHaveCount(1);
|
||||
});
|
||||
|
||||
test('should toggle conflict-only view', async ({ page }) => {
|
||||
await page.goto('/vulnerabilities/CVE-2025-12345?asset=sha256:abc123');
|
||||
|
||||
const claimTable = page.locator('st-claim-table');
|
||||
await expect(claimTable).toBeVisible({ timeout: 10000 });
|
||||
|
||||
// Get initial row count
|
||||
const initialRows = await claimTable.locator('tbody tr').count();
|
||||
|
||||
// Toggle conflicts only
|
||||
const toggle = claimTable.locator('input[type="checkbox"]');
|
||||
await toggle.check();
|
||||
|
||||
// Should filter to fewer rows
|
||||
const filteredRows = await claimTable.locator('tbody tr').count();
|
||||
expect(filteredRows).toBeLessThanOrEqual(initialRows);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user