use super::surface_coverage::surface_for_probe;
use super::{DifferentialReport, DivergenceKind, Severity};
use crate::fingerprint::surface::Criticality;
use crate::fingerprint::SurfaceCategory;
use serde::{Deserialize, Serialize};
pub const SCORECARD_SCHEMA_VERSION: u32 = 1;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScorecardSurface {
pub surface_id: String,
pub category: SurfaceCategory,
pub criticality: Criticality,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScorecardEntry {
pub surface: ScorecardSurface,
pub probe_name: String,
pub severity: Severity,
pub weight: u16,
pub benchmark_points: u16,
pub kind: DivergenceKind,
pub a_value: String,
pub b_value: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Scorecard {
pub schema_version: u32,
pub label_a: String,
pub label_b: String,
pub browser: String,
pub surfaces: usize,
pub agreed: usize,
pub diverged: usize,
pub errors: usize,
pub total_weight: u32,
pub lost_points: u32,
pub entries: Vec<ScorecardEntry>,
}
impl Scorecard {
pub fn is_clean(&self) -> bool {
self.lost_points == 0 && self.errors == 0 && self.diverged == 0
}
pub fn prioritized_fixes(&self) -> Vec<&ScorecardEntry> {
let mut v: Vec<_> = self.entries.iter().collect();
v.sort_by(|x, y| {
(
y.benchmark_points,
engine_first_rank(x.kind),
&x.surface.surface_id,
)
.cmp(&(
x.benchmark_points,
engine_first_rank(y.kind),
&y.surface.surface_id,
))
});
v
}
pub fn summary(&self) -> String {
format!(
"{} vs {} ({}): {}/{} surfaces agree, {} diverged, {} errors, {} lost points",
self.label_a,
self.label_b,
self.browser,
self.agreed,
self.surfaces,
self.diverged,
self.errors,
self.lost_points
)
}
}
fn engine_first_rank(kind: DivergenceKind) -> u8 {
match kind {
DivergenceKind::EngineDivergence => 0,
DivergenceKind::PersonaIntended => 1,
}
}
#[must_use]
pub fn weight_for_surface(criticality: Option<Criticality>, severity: Severity) -> u16 {
match criticality {
Some(Criticality::Critical) => 100,
Some(Criticality::High) => 40,
Some(Criticality::Medium) => 10,
Some(Criticality::Low) => 2,
None => match severity {
Severity::High => 30,
Severity::Medium => 8,
Severity::Low => 1,
},
}
}
#[must_use]
pub fn benchmark_points_for(weight: u16) -> u16 {
weight
}
#[derive(Debug, Clone)]
pub struct SeverityTuner {
pub boost: f64,
pub max_weight: u16,
}
impl Default for SeverityTuner {
fn default() -> Self {
Self {
boost: 1.5,
max_weight: 250,
}
}
}
impl SeverityTuner {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn tune(&self, scorecard: &mut Scorecard, blocked_surfaces: &[String]) {
let blocked: std::collections::HashSet<&str> =
blocked_surfaces.iter().map(|s| s.as_str()).collect();
let mut lost_points = 0u32;
for entry in &mut scorecard.entries {
let is_blocked = blocked.contains(entry.surface.surface_id.as_str())
|| blocked.contains(entry.probe_name.as_str());
if is_blocked {
let boosted = (f64::from(entry.weight) * self.boost) as u32;
let new_weight = boosted.min(u32::from(self.max_weight)).max(1) as u16;
entry.weight = new_weight;
entry.benchmark_points = benchmark_points_for(new_weight);
}
lost_points += u32::from(entry.benchmark_points);
}
scorecard.lost_points = lost_points;
}
pub fn tune_str(&self, scorecard: &mut Scorecard, blocked_surfaces: &[&str]) {
let owned: Vec<String> = blocked_surfaces.iter().map(|s| (*s).to_string()).collect();
self.tune(scorecard, &owned);
}
}
#[must_use]
pub fn scorecard_from_report(
report: &DifferentialReport,
browser: crate::fingerprint::UserAgentBrowser,
) -> Scorecard {
let mut entries = Vec::with_capacity(report.divergences.len());
let mut total_weight = 0u32;
let mut lost_points = 0u32;
for div in &report.divergences {
let inv_surface = surface_for_probe(&div.surface);
let criticality = inv_surface.map(|s| s.criticality);
let category = inv_surface
.map(|s| s.category)
.unwrap_or(SurfaceCategory::Navigator);
let surface_id = inv_surface
.map(|s| s.surface.to_string())
.unwrap_or_else(|| div.surface.clone());
let weight = weight_for_surface(criticality, div.severity);
let points = benchmark_points_for(weight);
total_weight += u32::from(weight);
lost_points += u32::from(points);
entries.push(ScorecardEntry {
surface: ScorecardSurface {
surface_id,
category,
criticality: criticality.unwrap_or(Criticality::Low),
},
probe_name: div.surface.clone(),
severity: div.severity,
weight,
benchmark_points: points,
kind: div.kind,
a_value: div.a_value.clone(),
b_value: div.b_value.clone(),
});
}
Scorecard {
schema_version: SCORECARD_SCHEMA_VERSION,
label_a: report.label_a.clone(),
label_b: report.label_b.clone(),
browser: format!("{browser:?}"),
surfaces: report.surfaces,
agreed: report.agreed,
diverged: report.diverged,
errors: report.errors,
total_weight,
lost_points,
entries,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fingerprint::UserAgentBrowser;
use crate::probe::surface_coverage::divergence_kind_for_probe;
use crate::probe::Divergence;
fn div(name: &str, sev: Severity) -> Divergence {
Divergence {
surface: name.to_string(),
surface_id: crate::probe::surface_coverage::surface_id_for_probe(name)
.map(|s| s.to_string()),
severity: sev,
kind: divergence_kind_for_probe(name),
a_value: "a".into(),
b_value: "b".into(),
}
}
fn rep(divs: Vec<Divergence>) -> DifferentialReport {
DifferentialReport {
label_a: "stock".into(),
label_b: "disguise".into(),
surfaces: 10,
agreed: 10 - divs.len(),
diverged: divs.len(),
errors: 0,
divergences: divs,
}
}
#[test]
fn webdriver_criticality_gives_max_weight_and_points() {
let d = div("navigator.webdriver", Severity::High);
let report = rep(vec![d]);
let sc = scorecard_from_report(&report, UserAgentBrowser::Firefox);
assert_eq!(sc.entries.len(), 1);
let e = &sc.entries[0];
assert_eq!(e.surface.surface_id, "navigator.webdriver");
assert_eq!(e.surface.criticality, Criticality::Critical);
assert_eq!(e.weight, 100);
assert_eq!(e.benchmark_points, 100);
assert_eq!(sc.lost_points, 100);
}
#[test]
fn webgl_high_surface_gets_high_weight() {
let d = div("WebGL UNMASKED_VENDOR not SwiftShader", Severity::High);
let sc = scorecard_from_report(&rep(vec![d]), UserAgentBrowser::Firefox);
let e = &sc.entries[0];
assert_eq!(e.surface.surface_id, "webgl.getParameter");
assert_eq!(e.surface.criticality, Criticality::High);
assert_eq!(e.weight, 40);
assert_eq!(e.benchmark_points, 40);
}
#[test]
fn unbridged_probe_falls_back_to_severity_weight() {
let d = div("window.chrome.runtime exists", Severity::High);
let sc = scorecard_from_report(&rep(vec![d]), UserAgentBrowser::Firefox);
let e = &sc.entries[0];
assert_eq!(e.weight, 30);
assert_eq!(e.benchmark_points, 30);
assert_eq!(e.surface.criticality, Criticality::Low);
}
#[test]
fn clean_scorecard_requires_zero_lost_points_and_errors() {
let clean = scorecard_from_report(&rep(vec![]), UserAgentBrowser::Firefox);
assert!(clean.is_clean());
let dirty = scorecard_from_report(
&rep(vec![div("navigator.webdriver", Severity::High)]),
UserAgentBrowser::Firefox,
);
assert!(!dirty.is_clean());
}
#[test]
fn serialization_round_trips_cleanly() {
let sc = scorecard_from_report(
&rep(vec![
div("navigator.webdriver", Severity::High),
div("navigator.plugins.length > 0", Severity::High),
]),
UserAgentBrowser::Firefox,
);
let json = serde_json::to_string(&sc).expect("serialize");
let back: Scorecard = serde_json::from_str(&json).expect("deserialize");
assert_eq!(back.schema_version, SCORECARD_SCHEMA_VERSION);
assert_eq!(back.lost_points, sc.lost_points);
assert_eq!(back.entries.len(), sc.entries.len());
assert_eq!(back.entries, sc.entries);
}
#[test]
fn prioritization_orders_by_points_then_engine_kind() {
let sc = scorecard_from_report(
&rep(vec![
div("navigator.hardwareConcurrency in [2, 16]", Severity::Low),
div("navigator.plugins.length > 0", Severity::High),
div("navigator.webdriver", Severity::High),
]),
UserAgentBrowser::Firefox,
);
let ordered: Vec<_> = sc
.prioritized_fixes()
.iter()
.map(|e| e.surface.surface_id.clone())
.collect();
assert_eq!(
ordered,
vec![
"navigator.webdriver",
"navigator.plugins.length",
"navigator.hardwareConcurrency",
]
);
assert_eq!(sc.prioritized_fixes()[0].benchmark_points, 100);
}
#[test]
fn summary_is_stable_and_includes_key_numbers() {
let sc = scorecard_from_report(
&rep(vec![div("navigator.webdriver", Severity::High)]),
UserAgentBrowser::Firefox,
);
let s = sc.summary();
assert!(s.contains("stock vs disguise"));
assert!(s.contains("1 diverged"));
assert!(s.contains("100 lost points"));
}
#[test]
fn severity_tuner_boosts_blocked_surface_weight_and_lost_points() {
let mut sc = scorecard_from_report(
&rep(vec![
div("navigator.webdriver", Severity::High),
div("navigator.plugins.length > 0", Severity::High),
]),
UserAgentBrowser::Firefox,
);
let base_webdriver_points = sc.entries[0].benchmark_points;
let base_plugins_points = sc.entries[1].benchmark_points;
let tuner = SeverityTuner::new();
tuner.tune_str(&mut sc, &["navigator.webdriver"]);
assert!(sc.entries[0].benchmark_points > base_webdriver_points);
assert_eq!(sc.entries[1].benchmark_points, base_plugins_points);
assert!(
sc.lost_points > u32::from(base_webdriver_points + base_plugins_points),
"lost_points must reflect the boosted weight"
);
}
#[test]
fn severity_tuner_caps_boosted_weight() {
let mut sc = scorecard_from_report(
&rep(vec![div("navigator.webdriver", Severity::High)]),
UserAgentBrowser::Firefox,
);
let tuner = SeverityTuner {
boost: 100.0,
max_weight: 200,
};
tuner.tune_str(&mut sc, &["navigator.webdriver"]);
assert_eq!(sc.entries[0].weight, 200);
assert_eq!(sc.entries[0].benchmark_points, 200);
}
#[test]
fn weight_table_matches_criticality_calibration() {
assert_eq!(
weight_for_surface(Some(Criticality::Critical), Severity::Low),
100
);
assert_eq!(
weight_for_surface(Some(Criticality::High), Severity::Low),
40
);
assert_eq!(
weight_for_surface(Some(Criticality::Medium), Severity::Low),
10
);
assert_eq!(weight_for_surface(Some(Criticality::Low), Severity::Low), 2);
assert_eq!(weight_for_surface(None, Severity::High), 30);
assert_eq!(weight_for_surface(None, Severity::Medium), 8);
assert_eq!(weight_for_surface(None, Severity::Low), 1);
}
}