use std::collections::{BTreeMap, BTreeSet};
use std::fs::File;
use std::io::BufReader;
use std::time::Duration;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use super::{
BrowserCookie, BrowserMetric, BrowserNetworkRequest, BrowserScreenshot, BrowserStorageEntry,
DebuggerAdapterKind, DebuggerArtifact, DebuggerConsoleEntry, DebuggerEvent,
DebuggerExceptionEntry, DebuggerManager, now_ms,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum DebuggerRecordingPhase {
Running,
Stopped,
Failed,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerRecording {
pub id: String,
pub session_id: String,
pub execution_id: Option<String>,
pub phase: DebuggerRecordingPhase,
pub max_frames: usize,
pub max_bytes: u64,
pub retained_frames: usize,
pub retained_bytes: u64,
pub retention_overflow: bool,
pub last_capture_id: Option<String>,
pub error: Option<String>,
pub started_at: u64,
pub stopped_at: Option<u64>,
pub updated_at: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerCapture {
pub id: String,
pub recording_id: String,
pub session_id: String,
pub sequence: u64,
pub at: u64,
pub reason: String,
pub url: String,
pub scroll_y: f64,
pub device_pixel_ratio: f64,
pub screenshot: BrowserScreenshot,
#[serde(default)]
pub state: DebuggerCaptureState,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerCaptureState {
pub console: Vec<DebuggerConsoleEntry>,
pub exceptions: Vec<DebuggerExceptionEntry>,
pub network: Vec<BrowserNetworkRequest>,
pub cookies: Vec<BrowserCookie>,
pub local_storage: Vec<BrowserStorageEntry>,
pub session_storage: Vec<BrowserStorageEntry>,
pub performance: Vec<BrowserMetric>,
pub styles: Vec<DebuggerStyleValue>,
pub accessibility: Vec<DebuggerAccessibilityIssue>,
pub warnings: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerStyleValue {
pub selector: String,
pub name: String,
pub value: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerAccessibilityIssue {
pub rule: String,
pub selector: String,
pub detail: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerMark {
pub id: String,
pub recording_id: String,
pub session_id: String,
pub name: String,
pub capture_id: String,
pub at: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerRecordingStart {
pub recording: DebuggerRecording,
pub initial_capture: DebuggerCapture,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerReplay {
pub recording_id: String,
pub capture_id: String,
pub session_id: String,
pub url: String,
pub scroll_y: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerPixelRegion {
pub x: u32,
pub y: u32,
pub width: u32,
pub height: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerStorageChange {
pub kind: String,
pub key: String,
pub before: Option<String>,
pub after: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerStyleChange {
pub selector: String,
pub name: String,
pub before: Option<String>,
pub after: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerPerformanceChange {
pub name: String,
pub before: Option<f64>,
pub after: Option<f64>,
pub delta: Option<f64>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DebuggerAfter {
pub id: String,
pub recording_id: String,
pub session_id: String,
pub before_capture_id: String,
pub after_capture_id: String,
pub diff_pixels: u64,
pub diff_percent: f64,
pub region: Option<DebuggerPixelRegion>,
pub console: Vec<DebuggerConsoleEntry>,
pub exceptions: Vec<DebuggerExceptionEntry>,
pub network_failures: Vec<BrowserNetworkRequest>,
pub storage: Vec<DebuggerStorageChange>,
pub styles: Vec<DebuggerStyleChange>,
pub accessibility: Vec<DebuggerAccessibilityIssue>,
pub performance: Vec<DebuggerPerformanceChange>,
pub report: DebuggerArtifact,
pub at: u64,
}
impl DebuggerManager {
pub async fn recording_start(
&self,
session_id: &str,
max_frames: usize,
max_bytes: u64,
) -> Result<DebuggerRecordingStart, String> {
if self.store.active_debugger_recording(session_id)?.is_some() {
return Err(format!(
"Debugger session \"{session_id}\" already has an active recording"
));
}
let session_record = self
.store
.debugger_session(session_id)?
.ok_or_else(|| format!("Debugger session \"{session_id}\" not found"))?;
if session_record.adapter != DebuggerAdapterKind::BrowserCdp {
return Err(format!(
"Debugger session \"{session_id}\" is not a page target"
));
}
let at = now_ms();
let mut recording = DebuggerRecording {
id: uuid::Uuid::now_v7().to_string(),
session_id: session_id.to_string(),
execution_id: session_record.execution_id,
phase: DebuggerRecordingPhase::Running,
max_frames: max_frames.max(2),
max_bytes: max_bytes.max(1),
retained_frames: 0,
retained_bytes: 0,
retention_overflow: false,
last_capture_id: None,
error: None,
started_at: at,
stopped_at: None,
updated_at: at,
};
self.store.put_debugger_recording(&recording)?;
let initial_capture = match self
.recording_capture_for(&recording, "start".to_string())
.await
{
Ok(capture) => capture,
Err(error) => {
recording.phase = DebuggerRecordingPhase::Failed;
recording.error = Some(error.clone());
recording.stopped_at = Some(now_ms());
recording.updated_at = recording.stopped_at.unwrap_or(at);
self.store.put_debugger_recording(&recording)?;
return Err(error);
}
};
let recording = self
.store
.debugger_recording(&recording.id)?
.ok_or_else(|| "Recording disappeared after initial capture".to_string())?;
self.spawn_recording_worker(session_id).await;
self.append_recording_event(
&recording,
"debugger.recording.started",
json!({"capture_id":initial_capture.id}),
);
Ok(DebuggerRecordingStart {
recording,
initial_capture,
})
}
pub fn recording_status(&self, session_id: &str) -> Result<Option<DebuggerRecording>, String> {
self.store.latest_debugger_recording(session_id)
}
pub fn recording_list(&self) -> Result<Vec<DebuggerRecording>, String> {
self.store.debugger_recordings()
}
pub fn recording_captures(&self, recording_id: &str) -> Result<Vec<DebuggerCapture>, String> {
self.store.debugger_captures(recording_id)
}
pub fn recording_marks(&self, recording_id: &str) -> Result<Vec<DebuggerMark>, String> {
self.store.debugger_marks(recording_id)
}
pub async fn recording_capture(
&self,
session_id: &str,
reason: String,
) -> Result<DebuggerCapture, String> {
let recording = self
.store
.active_debugger_recording(session_id)?
.ok_or_else(|| format!("Debugger session \"{session_id}\" is not recording"))?;
self.recording_capture_for(&recording, reason).await
}
pub async fn recording_mark(
&self,
session_id: &str,
name: String,
) -> Result<DebuggerMark, String> {
if name.trim().is_empty() {
return Err("Recording mark name cannot be empty".to_string());
}
let recording = self
.store
.active_debugger_recording(session_id)?
.ok_or_else(|| format!("Debugger session \"{session_id}\" is not recording"))?;
let capture = self
.recording_capture_for(&recording, format!("mark:{name}"))
.await?;
let mark = DebuggerMark {
id: uuid::Uuid::now_v7().to_string(),
recording_id: recording.id.clone(),
session_id: session_id.to_string(),
name,
capture_id: capture.id,
at: capture.at,
};
self.store.put_debugger_mark(&mark)?;
self.append_recording_event(
&recording,
"debugger.recording.marked",
json!({"mark_id":mark.id,"capture_id":mark.capture_id,"name":mark.name}),
);
Ok(mark)
}
pub async fn recording_stop(&self, session_id: &str) -> Result<DebuggerRecording, String> {
let mut recording = self
.store
.active_debugger_recording(session_id)?
.ok_or_else(|| format!("Debugger session \"{session_id}\" is not recording"))?;
let final_capture = self
.recording_capture_for(&recording, "stop".to_string())
.await?;
recording = self
.store
.debugger_recording(&recording.id)?
.ok_or_else(|| "Recording disappeared before stop".to_string())?;
recording.phase = DebuggerRecordingPhase::Stopped;
recording.stopped_at = Some(now_ms());
recording.updated_at = recording.stopped_at.unwrap_or(recording.updated_at);
self.store.put_debugger_recording(&recording)?;
self.stop_recording_worker(session_id).await;
self.append_recording_event(
&recording,
"debugger.recording.stopped",
json!({"capture_id":final_capture.id}),
);
Ok(recording)
}
pub async fn recording_replay(
&self,
session_id: &str,
capture_id: &str,
timeout: Duration,
) -> Result<DebuggerReplay, String> {
let capture = self
.store
.debugger_capture(capture_id)?
.ok_or_else(|| format!("Recording capture \"{capture_id}\" not found"))?;
if capture.session_id != session_id {
return Err(format!(
"Recording capture \"{capture_id}\" belongs to session \"{}\"",
capture.session_id
));
}
self.browser_navigate(session_id, "url", Some(&capture.url), timeout)
.await?;
let session = self.session(session_id).await?;
session
.send(
"Runtime.evaluate",
json!({
"expression":format!("scrollTo(0, {})", capture.scroll_y),
"returnByValue":true
}),
)
.await?;
Ok(DebuggerReplay {
recording_id: capture.recording_id,
capture_id: capture.id,
session_id: session_id.to_string(),
url: capture.url,
scroll_y: capture.scroll_y,
})
}
pub async fn recording_after(
&self,
session_id: &str,
anchor: Option<&str>,
) -> Result<DebuggerAfter, String> {
let recording = self
.store
.active_debugger_recording(session_id)?
.ok_or_else(|| format!("Debugger session \"{session_id}\" is not recording"))?;
let captures = self.store.debugger_captures(&recording.id)?;
let before = resolve_after_anchor(&self.store, &recording.id, &captures, anchor)?;
let after_capture = self
.recording_capture_for(&recording, "after".to_string())
.await?;
let (diff_pixels, total_pixels, region) = pixel_diff(
&before.screenshot.artifact.path,
&after_capture.screenshot.artifact.path,
)?;
let console = appended_values(&before.state.console, &after_capture.state.console);
let exceptions = appended_values(&before.state.exceptions, &after_capture.state.exceptions);
let before_requests = before
.state
.network
.iter()
.map(|request| request.id.as_str())
.collect::<BTreeSet<_>>();
let network_failures = after_capture
.state
.network
.iter()
.filter(|request| {
!before_requests.contains(request.id.as_str())
&& (request.error.is_some()
|| request.status.is_some_and(|status| status >= 400))
})
.cloned()
.collect::<Vec<_>>();
let storage = storage_changes(&before.state, &after_capture.state);
let styles = style_changes(&before.state.styles, &after_capture.state.styles);
let before_a11y = before
.state
.accessibility
.iter()
.map(a11y_key)
.collect::<BTreeSet<_>>();
let accessibility = after_capture
.state
.accessibility
.iter()
.filter(|issue| !before_a11y.contains(&a11y_key(issue)))
.cloned()
.collect::<Vec<_>>();
let performance =
performance_changes(&before.state.performance, &after_capture.state.performance);
let id = uuid::Uuid::now_v7().to_string();
let at = now_ms();
let payload = json!({
"id":id,
"recording_id":recording.id,
"session_id":session_id,
"before_capture_id":before.id,
"after_capture_id":after_capture.id,
"pixels":{"changed":diff_pixels,"total":total_pixels,"percent":if total_pixels == 0 { 0.0 } else { diff_pixels as f64 / total_pixels as f64 * 100.0 },"region":region},
"console":console,
"exceptions":exceptions,
"network_failures":network_failures,
"storage":storage,
"styles":styles,
"accessibility":accessibility,
"performance":performance,
"warnings":{"before":before.state.warnings,"after":after_capture.state.warnings}
});
let report_bytes = render_after_report(&payload).into_bytes();
let report = self.store.put_debugger_artifact(
session_id,
recording.execution_id.as_deref(),
"debugger_after_report",
"text/html",
&report_bytes,
)?;
let result = DebuggerAfter {
id,
recording_id: recording.id.clone(),
session_id: session_id.to_string(),
before_capture_id: before.id,
after_capture_id: after_capture.id,
diff_pixels,
diff_percent: if total_pixels == 0 {
0.0
} else {
diff_pixels as f64 / total_pixels as f64 * 100.0
},
region,
console,
exceptions,
network_failures,
storage,
styles,
accessibility,
performance,
report,
at,
};
self.store.put_debugger_after(&result)?;
self.append_recording_event(
&recording,
"debugger.recording.after",
json!({
"after_id":result.id,
"before_capture_id":result.before_capture_id,
"after_capture_id":result.after_capture_id,
"report_id":result.report.id
}),
);
Ok(result)
}
pub(super) async fn resume_recording_worker(&self, session_id: &str) {
if self
.store
.active_debugger_recording(session_id)
.ok()
.flatten()
.is_some()
{
self.spawn_recording_worker(session_id).await;
}
}
async fn recording_capture_for(
&self,
recording: &DebuggerRecording,
reason: String,
) -> Result<DebuggerCapture, String> {
let lock = {
let mut locks = self.recording_capture_locks.lock().await;
locks
.entry(recording.session_id.clone())
.or_insert_with(|| std::sync::Arc::new(tokio::sync::Mutex::new(())))
.clone()
};
let _guard = lock.lock().await;
let recording = self
.store
.debugger_recording(&recording.id)?
.ok_or_else(|| format!("Recording \"{}\" not found", recording.id))?;
if recording.phase != DebuggerRecordingPhase::Running {
return Err(format!("Recording \"{}\" is not running", recording.id));
}
let session = self.session(&recording.session_id).await?;
let metadata = session
.send(
"Runtime.evaluate",
json!({
"expression":"({url:location.href,scrollY,devicePixelRatio})",
"returnByValue":true
}),
)
.await?;
let value = metadata
.pointer("/result/value")
.cloned()
.unwrap_or(Value::Null);
let screenshot = self
.browser_screenshot(&recording.session_id, None, false, None, None, false)
.await?;
let state = self.recording_capture_state(&session).await;
let capture = self.store.put_debugger_capture(DebuggerCapture {
id: uuid::Uuid::now_v7().to_string(),
recording_id: recording.id.clone(),
session_id: recording.session_id.clone(),
sequence: 0,
at: now_ms(),
reason,
url: value
.get("url")
.and_then(Value::as_str)
.unwrap_or_default()
.to_string(),
scroll_y: value.get("scrollY").and_then(Value::as_f64).unwrap_or(0.0),
device_pixel_ratio: value
.get("devicePixelRatio")
.and_then(Value::as_f64)
.unwrap_or(1.0),
screenshot,
state,
})?;
let retained = self.store.trim_debugger_captures(
&recording.id,
recording.max_frames,
recording.max_bytes,
)?;
let mut updated = recording.clone();
updated.retained_frames = retained
.iter()
.filter(|capture| capture.screenshot.bytes > 0)
.count();
updated.retained_bytes = retained
.iter()
.map(|capture| capture.screenshot.bytes)
.sum();
updated.retention_overflow = updated.retained_frames > updated.max_frames
|| updated.retained_bytes > updated.max_bytes;
updated.last_capture_id = Some(capture.id.clone());
updated.updated_at = capture.at;
self.store.put_debugger_recording(&updated)?;
self.append_recording_event(
&updated,
"debugger.recording.captured",
json!({
"capture_id":capture.id,
"sequence":capture.sequence,
"reason":capture.reason,
"artifact_id":capture.screenshot.artifact.id
}),
);
Ok(capture)
}
async fn recording_capture_state(
&self,
session: &super::DebuggerSession,
) -> DebuggerCaptureState {
let snapshot = session.state.borrow().clone();
let mut state = DebuggerCaptureState {
console: snapshot.console,
exceptions: snapshot.exceptions,
network: snapshot.browser.requests,
..DebuggerCaptureState::default()
};
match self.browser_cookies(&session.id).await {
Ok(cookies) => state.cookies = cookies,
Err(error) => state.warnings.push(format!("cookies: {error}")),
}
for (kind, target) in [
("local", &mut state.local_storage),
("session", &mut state.session_storage),
] {
match self.browser_storage(&session.id, kind).await {
Ok(entries) => *target = entries,
Err(error) => state.warnings.push(format!("{kind} storage: {error}")),
}
}
match self.browser_performance(&session.id).await {
Ok(metrics) => state.performance = metrics,
Err(error) => state.warnings.push(format!("performance: {error}")),
}
match session
.send(
"Runtime.evaluate",
json!({
"expression":r#"(() => {
const props=['display','position','color','background-color','font-size','width','height'];
return [...document.querySelectorAll('[id],button,input,select,a,img')].slice(0,500).flatMap((el,index)=>{
const selector=el.id ? '#'+CSS.escape(el.id) : el.tagName.toLowerCase()+':nth-of-type('+(index+1)+')';
const style=getComputedStyle(el);
return props.map(name=>({selector,name,value:style.getPropertyValue(name)}));
});
})()"#,
"returnByValue":true
}),
)
.await
{
Ok(value) => match serde_json::from_value(
value
.pointer("/result/value")
.cloned()
.unwrap_or(Value::Null),
) {
Ok(styles) => state.styles = styles,
Err(error) => state.warnings.push(format!("styles: {error}")),
},
Err(error) => state.warnings.push(format!("styles: {error}")),
}
match session
.send(
"Runtime.evaluate",
json!({
"expression":r#"(() => {
const issues=[];
const selector=el=>el.id ? '#'+CSS.escape(el.id) : el.tagName.toLowerCase();
for(const el of document.querySelectorAll('img:not([alt])')) issues.push({rule:'image-alt',selector:selector(el),detail:'Image has no alt attribute'});
for(const el of document.querySelectorAll('input,select,textarea')) {
if(!el.getAttribute('aria-label') && !el.getAttribute('aria-labelledby') && !document.querySelector(`label[for="${CSS.escape(el.id)}"]`)) issues.push({rule:'form-name',selector:selector(el),detail:'Form control has no accessible name'});
}
for(const el of document.querySelectorAll('button,a[href]')) if(!(el.textContent||'').trim() && !el.getAttribute('aria-label')) issues.push({rule:'control-name',selector:selector(el),detail:'Interactive control has no accessible name'});
const ids=new Map(); for(const el of document.querySelectorAll('[id]')) { const prior=ids.get(el.id); if(prior) issues.push({rule:'duplicate-id',selector:'#'+CSS.escape(el.id),detail:'Document contains a duplicate id'}); else ids.set(el.id,el); }
return issues;
})()"#,
"returnByValue":true
}),
)
.await
{
Ok(value) => match serde_json::from_value(
value
.pointer("/result/value")
.cloned()
.unwrap_or(Value::Null),
) {
Ok(issues) => state.accessibility = issues,
Err(error) => state.warnings.push(format!("accessibility: {error}")),
},
Err(error) => state.warnings.push(format!("accessibility: {error}")),
}
state
}
async fn spawn_recording_worker(&self, session_id: &str) {
self.stop_recording_worker(session_id).await;
let Ok(session) = self.session(session_id).await else {
return;
};
let mut state = session.state.clone();
let manager = self.clone();
let session_id = session_id.to_string();
let task_session = session_id.clone();
let mut after_event = state
.borrow()
.browser
.page_events
.last()
.map_or(0, |event| event.id);
let task = tokio::spawn(async move {
while state.changed().await.is_ok() {
let latest = state
.borrow()
.browser
.page_events
.iter()
.filter(|event| event.id > after_event && event.name == "frameNavigated")
.map(|event| event.id)
.max();
let Some(latest) = latest else {
continue;
};
after_event = latest;
tokio::time::sleep(Duration::from_millis(100)).await;
if manager
.recording_capture(&task_session, "navigation".to_string())
.await
.is_err()
{
break;
}
}
});
self.recording_tasks.lock().await.insert(session_id, task);
}
async fn stop_recording_worker(&self, session_id: &str) {
if let Some(task) = self.recording_tasks.lock().await.remove(session_id) {
task.abort();
}
}
fn append_recording_event(&self, recording: &DebuggerRecording, kind: &str, details: Value) {
let _ = self.store.append_debugger_event(DebuggerEvent {
sequence: 0,
id: uuid::Uuid::now_v7().to_string(),
session_id: recording.session_id.clone(),
execution_id: recording.execution_id.clone(),
at: now_ms(),
kind: kind.to_string(),
details: json!({"recording_id":recording.id,"data":details}),
});
}
}
fn resolve_after_anchor(
store: &crate::store::Store,
recording_id: &str,
captures: &[DebuggerCapture],
anchor: Option<&str>,
) -> Result<DebuggerCapture, String> {
let Some(anchor) = anchor else {
return captures
.last()
.cloned()
.ok_or_else(|| "Recording has no capture to compare".to_string());
};
if let Some(id) = anchor.strip_prefix("capture:").or(Some(anchor))
&& let Some(capture) = captures.iter().find(|capture| capture.id == id)
{
return Ok(capture.clone());
}
if let Some(name) = anchor.strip_prefix("mark:") {
let marks = store.debugger_marks(recording_id)?;
let mark = marks
.iter()
.rev()
.find(|mark| mark.name == name)
.ok_or_else(|| format!("Recording mark \"{name}\" not found"))?;
return captures
.iter()
.find(|capture| capture.id == mark.capture_id)
.cloned()
.ok_or_else(|| format!("Marked capture \"{}\" is not retained", mark.capture_id));
}
Err(format!(
"Unknown recording anchor \"{anchor}\"; use capture:ID or mark:NAME"
))
}
fn appended_values<T>(before: &[T], after: &[T]) -> Vec<T>
where
T: Clone + Serialize,
{
let before = before
.iter()
.filter_map(|value| serde_json::to_string(value).ok())
.collect::<BTreeSet<_>>();
after
.iter()
.filter(|value| {
serde_json::to_string(value)
.ok()
.is_none_or(|value| !before.contains(&value))
})
.cloned()
.collect()
}
fn storage_changes(
before: &DebuggerCaptureState,
after: &DebuggerCaptureState,
) -> Vec<DebuggerStorageChange> {
let mut changes = Vec::new();
for (kind, before, after) in [
("local", &before.local_storage, &after.local_storage),
("session", &before.session_storage, &after.session_storage),
] {
let before = before
.iter()
.map(|entry| (entry.key.clone(), entry.value.clone()))
.collect::<BTreeMap<_, _>>();
let after = after
.iter()
.map(|entry| (entry.key.clone(), entry.value.clone()))
.collect::<BTreeMap<_, _>>();
for key in before.keys().chain(after.keys()).collect::<BTreeSet<_>>() {
if before.get(key) != after.get(key) {
changes.push(DebuggerStorageChange {
kind: kind.to_string(),
key: key.clone(),
before: before.get(key).cloned(),
after: after.get(key).cloned(),
});
}
}
}
changes
}
fn style_changes(
before: &[DebuggerStyleValue],
after: &[DebuggerStyleValue],
) -> Vec<DebuggerStyleChange> {
let before = before
.iter()
.map(|value| {
(
(value.selector.clone(), value.name.clone()),
value.value.clone(),
)
})
.collect::<BTreeMap<_, _>>();
let after = after
.iter()
.map(|value| {
(
(value.selector.clone(), value.name.clone()),
value.value.clone(),
)
})
.collect::<BTreeMap<_, _>>();
before
.keys()
.chain(after.keys())
.collect::<BTreeSet<_>>()
.into_iter()
.filter(|key| before.get(*key) != after.get(*key))
.map(|key| DebuggerStyleChange {
selector: key.0.clone(),
name: key.1.clone(),
before: before.get(key).cloned(),
after: after.get(key).cloned(),
})
.collect()
}
fn performance_changes(
before: &[BrowserMetric],
after: &[BrowserMetric],
) -> Vec<DebuggerPerformanceChange> {
let before = before
.iter()
.map(|metric| (metric.name.clone(), metric.value))
.collect::<BTreeMap<_, _>>();
let after = after
.iter()
.map(|metric| (metric.name.clone(), metric.value))
.collect::<BTreeMap<_, _>>();
before
.keys()
.chain(after.keys())
.collect::<BTreeSet<_>>()
.into_iter()
.map(|name| {
let before_value = before.get(name).copied();
let after_value = after.get(name).copied();
DebuggerPerformanceChange {
name: name.clone(),
before: before_value,
after: after_value,
delta: before_value
.zip(after_value)
.map(|(before, after)| after - before),
}
})
.collect()
}
fn a11y_key(issue: &DebuggerAccessibilityIssue) -> String {
format!("{}\0{}\0{}", issue.rule, issue.selector, issue.detail)
}
pub(super) fn pixel_diff(
before_path: &str,
after_path: &str,
) -> Result<(u64, u64, Option<DebuggerPixelRegion>), String> {
let before = decode_png(before_path)?;
let after = decode_png(after_path)?;
let width = before.0.max(after.0);
let height = before.1.max(after.1);
let mut changed = 0_u64;
let mut min_x = width;
let mut min_y = height;
let mut max_x = 0_u32;
let mut max_y = 0_u32;
for y in 0..height {
for x in 0..width {
let before_pixel = rgba_at(&before, x, y);
let after_pixel = rgba_at(&after, x, y);
if before_pixel != after_pixel {
changed = changed.saturating_add(1);
min_x = min_x.min(x);
min_y = min_y.min(y);
max_x = max_x.max(x);
max_y = max_y.max(y);
}
}
}
let region = (changed > 0).then(|| DebuggerPixelRegion {
x: min_x,
y: min_y,
width: max_x - min_x + 1,
height: max_y - min_y + 1,
});
Ok((changed, u64::from(width) * u64::from(height), region))
}
fn decode_png(path: &str) -> Result<(u32, u32, Vec<u8>), String> {
let file = File::open(path).map_err(|error| format!("Could not open PNG {path}: {error}"))?;
let mut decoder = png::Decoder::new(BufReader::new(file));
decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
let mut reader = decoder
.read_info()
.map_err(|error| format!("Could not decode PNG {path}: {error}"))?;
let size = reader
.output_buffer_size()
.ok_or_else(|| format!("PNG {path} has no bounded output size"))?;
let mut buffer = vec![0; size];
let info = reader
.next_frame(&mut buffer)
.map_err(|error| format!("Could not read PNG {path}: {error}"))?;
let bytes = &buffer[..info.buffer_size()];
let mut rgba = Vec::with_capacity(info.width as usize * info.height as usize * 4);
match info.color_type {
png::ColorType::Rgba => rgba.extend_from_slice(bytes),
png::ColorType::Rgb => {
let (pixels, _) = bytes.as_chunks::<3>();
for pixel in pixels {
rgba.extend_from_slice(&[pixel[0], pixel[1], pixel[2], 255]);
}
}
png::ColorType::Grayscale => {
for value in bytes {
rgba.extend_from_slice(&[*value, *value, *value, 255]);
}
}
png::ColorType::GrayscaleAlpha => {
let (pixels, _) = bytes.as_chunks::<2>();
for pixel in pixels {
rgba.extend_from_slice(&[pixel[0], pixel[0], pixel[0], pixel[1]]);
}
}
png::ColorType::Indexed => {
return Err(format!("PNG {path} remained indexed after expansion"));
}
}
Ok((info.width, info.height, rgba))
}
fn rgba_at(image: &(u32, u32, Vec<u8>), x: u32, y: u32) -> [u8; 4] {
if x >= image.0 || y >= image.1 {
return [0, 0, 0, 0];
}
let index = ((y * image.0 + x) * 4) as usize;
image.2[index..index + 4].try_into().unwrap_or([0, 0, 0, 0])
}
fn render_after_report(payload: &Value) -> String {
let json = serde_json::to_string_pretty(payload).unwrap_or_else(|_| "{}".to_string());
format!(
"<!doctype html><html lang=\"en\"><meta charset=\"utf-8\"><title>apoc browser after report</title><style>body{{font:14px ui-monospace,monospace;margin:2rem;max-width:100rem}}pre{{white-space:pre-wrap;overflow-wrap:anywhere;background:#111;color:#eee;padding:1rem;border-radius:.5rem}}</style><h1>apoc browser after report</h1><pre>{}</pre></html>",
html_escape(&json)
)
}
fn html_escape(value: &str) -> String {
value
.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
}
#[cfg(test)]
mod tests {
use super::*;
fn write_png(path: &std::path::Path, width: u32, height: u32, rgba: &[u8]) {
let file = File::create(path).unwrap();
let mut encoder = png::Encoder::new(file, width, height);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
encoder
.write_header()
.unwrap()
.write_image_data(rgba)
.unwrap();
}
#[test]
fn pixel_diff_returns_no_region_for_identical_images() {
let dir = tempfile::tempdir().unwrap();
let before = dir.path().join("before.png");
let after = dir.path().join("after.png");
let pixels = [10, 20, 30, 255, 40, 50, 60, 255];
write_png(&before, 2, 1, &pixels);
write_png(&after, 2, 1, &pixels);
let result = pixel_diff(before.to_str().unwrap(), after.to_str().unwrap()).unwrap();
assert_eq!(result.0, 0);
assert_eq!(result.1, 2);
assert!(result.2.is_none());
}
#[test]
fn pixel_diff_compares_the_union_of_different_image_sizes() {
let dir = tempfile::tempdir().unwrap();
let before = dir.path().join("before.png");
let after = dir.path().join("after.png");
write_png(&before, 1, 1, &[255, 0, 0, 255]);
write_png(&after, 2, 1, &[255, 0, 0, 255, 0, 255, 0, 255]);
let result = pixel_diff(before.to_str().unwrap(), after.to_str().unwrap()).unwrap();
assert_eq!(result.0, 1);
assert_eq!(result.1, 2);
let region = result.2.unwrap();
assert_eq!(region.x, 1);
assert_eq!(region.y, 0);
assert_eq!(region.width, 1);
assert_eq!(region.height, 1);
}
}