use chromiumoxide::cdp::browser_protocol::network::{ErrorReason, ResourceType};
use std::sync::atomic::{AtomicU64, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ResourceKind {
Document,
Script,
Stylesheet,
Image,
Media,
Font,
Xhr,
Fetch,
Other,
}
impl From<ResourceType> for ResourceKind {
fn from(rt: ResourceType) -> Self {
match rt {
ResourceType::Document => Self::Document,
ResourceType::Script => Self::Script,
ResourceType::Stylesheet => Self::Stylesheet,
ResourceType::Image => Self::Image,
ResourceType::Media => Self::Media,
ResourceType::Font => Self::Font,
ResourceType::Xhr => Self::Xhr,
ResourceType::Fetch => Self::Fetch,
_ => Self::Other,
}
}
}
pub const AD_DOMAIN_BLACKLIST: &[&str] = &[
"doubleclick.net",
"googlesyndication.com",
"googleadservices.com",
"googletagmanager.com",
"googletagservices.com",
"adservice.google.com",
"adsense.com",
"google-analytics.com",
"ssl.google-analytics.com",
"facebook.com/tr",
"facebook.net",
"connect.facebook.net",
"hotjar.com",
"quantserve.com",
"scorecardresearch.com",
"adnxs.com", "taboola.com",
"outbrain.com",
"criteo.com",
"rubiconproject.com",
"pubmatic.com",
"openx.net",
"casalemedia.com", "agkn.com",
"bluekai.com", "adform.net",
"yieldmo.com",
"moatads.com",
"admixer.net",
"ads-twitter.com",
"analytics.twitter.com",
"px.ads.linkedin.com",
"analytics.tiktok.com",
"bat.bing.com",
"amazon-adsystem.com",
];
pub const MEDIA_RESOURCE_KINDS: &[ResourceKind] =
&[ResourceKind::Image, ResourceKind::Media, ResourceKind::Font];
#[derive(Debug)]
pub struct InterceptController {
pub block_ads: bool,
pub block_media: bool,
intercepted_count: AtomicU64,
}
impl InterceptController {
#[must_use]
pub fn new(block_ads: bool, block_media: bool) -> Self {
Self {
block_ads,
block_media,
intercepted_count: AtomicU64::new(0),
}
}
#[must_use]
pub fn disabled() -> Self {
Self::new(false, false)
}
#[must_use]
pub fn should_block(&self, url: &str, kind: Option<ResourceKind>) -> bool {
if self.block_ads && self.should_block_ad_domain(url) {
return true;
}
if self.block_media && self.should_block_media(kind) {
return true;
}
false
}
#[must_use]
pub fn should_block_ad_domain(&self, url: &str) -> bool {
if !self.block_ads {
return false;
}
let lower = url.to_ascii_lowercase();
AD_DOMAIN_BLACKLIST.iter().any(|d| lower.contains(d))
}
#[must_use]
pub fn should_block_media(&self, kind: Option<ResourceKind>) -> bool {
if !self.block_media {
return false;
}
match kind {
Some(k) => MEDIA_RESOURCE_KINDS.contains(&k),
None => false,
}
}
pub fn record_block(&self) {
self.intercepted_count.fetch_add(1, Ordering::Relaxed);
}
#[must_use]
pub fn intercepted_count(&self) -> u64 {
self.intercepted_count.load(Ordering::Relaxed)
}
}
impl Default for InterceptController {
fn default() -> Self {
Self::disabled()
}
}
impl Clone for InterceptController {
fn clone(&self) -> Self {
Self::new(self.block_ads, self.block_media)
}
}
pub const BLOCK_REASON: ErrorReason = ErrorReason::BlockedByClient;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ad_domain_blacklist_has_at_least_20_entries() {
assert!(
AD_DOMAIN_BLACKLIST.len() >= 20,
"AD_DOMAIN_BLACKLIST must have >= 20 entries, got {}",
AD_DOMAIN_BLACKLIST.len()
);
}
#[test]
fn ad_domain_blacklist_contains_required_entries() {
let required = [
"doubleclick.net",
"google-analytics.com",
"facebook.com/tr",
"googletagmanager.com",
"hotjar.com",
"quantserve.com",
"scorecardresearch.com",
];
for r in &required {
assert!(
AD_DOMAIN_BLACKLIST.iter().any(|d| d == r),
"AD_DOMAIN_BLACKLIST missing required entry: {}",
r
);
}
}
#[test]
fn ad_domain_blacklist_entries_are_lowercase() {
for d in AD_DOMAIN_BLACKLIST {
assert!(
d.chars().all(|c| !c.is_ascii_uppercase()),
"AD_DOMAIN_BLACKLIST entry must be lowercase: {}",
d
);
}
}
#[test]
fn ad_domain_blacklist_no_duplicates() {
let mut sorted = AD_DOMAIN_BLACKLIST.to_vec();
sorted.sort();
let dedup_count = sorted.windows(2).filter(|w| w[0] == w[1]).count();
assert_eq!(dedup_count, 0, "AD_DOMAIN_BLACKLIST has duplicates");
}
#[test]
fn should_block_ad_domain_doubleclick() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block_ad_domain("https://doubleclick.net/pixel.gif"));
assert!(ctrl.should_block_ad_domain("https://ad.doubleclick.net/ddm/track"));
}
#[test]
fn should_block_ad_domain_google_analytics() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block_ad_domain("https://google-analytics.com/collect"));
assert!(ctrl.should_block_ad_domain("https://ssl.google-analytics.com/g.js"));
}
#[test]
fn should_block_ad_domain_facebook_tracker() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block_ad_domain("https://facebook.com/tr?id=123"));
}
#[test]
fn should_block_ad_domain_normal_url_passes() {
let ctrl = InterceptController::new(true, false);
assert!(!ctrl.should_block_ad_domain("https://example.com/index.html"));
assert!(!ctrl.should_block_ad_domain("https://www.wikipedia.org/wiki/Main_Page"));
assert!(!ctrl.should_block_ad_domain("https://github.com/rust-lang/rust"));
}
#[test]
fn should_block_ad_domain_case_insensitive() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block_ad_domain("HTTPS://DOUBLECLICK.NET/X"));
assert!(ctrl.should_block_ad_domain("https://Google-Analytics.com/collect"));
}
#[test]
fn should_block_ad_domain_disabled_passes_everything() {
let ctrl = InterceptController::new(false, false);
assert!(!ctrl.should_block_ad_domain("https://doubleclick.net/pixel.gif"));
assert!(!ctrl.should_block_ad_domain("https://google-analytics.com/collect"));
}
#[test]
fn should_block_ad_domain_empty_url_passes() {
let ctrl = InterceptController::new(true, false);
assert!(!ctrl.should_block_ad_domain(""));
}
#[test]
fn should_block_media_image_when_enabled() {
let ctrl = InterceptController::new(false, true);
assert!(ctrl.should_block_media(Some(ResourceKind::Image)));
}
#[test]
fn should_block_media_media_when_enabled() {
let ctrl = InterceptController::new(false, true);
assert!(ctrl.should_block_media(Some(ResourceKind::Media)));
}
#[test]
fn should_block_media_font_when_enabled() {
let ctrl = InterceptController::new(false, true);
assert!(ctrl.should_block_media(Some(ResourceKind::Font)));
}
#[test]
fn should_block_media_disabled_passes_all_resource_types() {
let ctrl = InterceptController::new(false, false);
assert!(!ctrl.should_block_media(Some(ResourceKind::Image)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Media)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Font)));
}
#[test]
fn should_block_media_passes_non_media_resource_types() {
let ctrl = InterceptController::new(false, true);
assert!(!ctrl.should_block_media(Some(ResourceKind::Document)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Script)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Stylesheet)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Xhr)));
assert!(!ctrl.should_block_media(Some(ResourceKind::Fetch)));
}
#[test]
fn should_block_media_none_resource_type_returns_false() {
let ctrl = InterceptController::new(false, true);
assert!(!ctrl.should_block_media(None));
}
#[test]
fn should_block_ads_blacklist_hit_returns_true() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block("https://doubleclick.net/x", None));
assert!(ctrl.should_block(
"https://google-analytics.com/collect",
Some(ResourceKind::Xhr)
));
}
#[test]
fn should_block_normal_url_passes() {
let ctrl = InterceptController::new(true, false);
assert!(!ctrl.should_block("https://example.com/index.html", None));
assert!(!ctrl.should_block("https://example.com/image.png", Some(ResourceKind::Image)));
}
#[test]
fn should_block_media_image_request_when_block_media() {
let ctrl = InterceptController::new(false, true);
assert!(ctrl.should_block("https://example.com/image.png", Some(ResourceKind::Image)));
}
#[test]
fn should_block_media_disabled_passes_image() {
let ctrl = InterceptController::new(false, false);
assert!(!ctrl.should_block("https://example.com/image.png", Some(ResourceKind::Image)));
}
#[test]
fn should_block_both_ad_and_media_hit_returns_true() {
let ctrl = InterceptController::new(true, true);
assert!(ctrl.should_block("https://doubleclick.net/x", None));
assert!(ctrl.should_block("https://example.com/banner.png", Some(ResourceKind::Image)));
}
#[test]
fn should_block_disabled_passes_everything() {
let ctrl = InterceptController::new(false, false);
assert!(!ctrl.should_block("https://doubleclick.net/x", None));
assert!(!ctrl.should_block("https://example.com/image.png", Some(ResourceKind::Image)));
}
#[test]
fn should_block_ad_url_with_media_type_returns_true() {
let ctrl = InterceptController::new(true, false);
assert!(ctrl.should_block(
"https://doubleclick.net/banner.png",
Some(ResourceKind::Image)
));
}
#[test]
fn record_block_increments_count() {
let ctrl = InterceptController::new(true, false);
assert_eq!(ctrl.intercepted_count(), 0);
ctrl.record_block();
ctrl.record_block();
ctrl.record_block();
assert_eq!(ctrl.intercepted_count(), 3);
}
#[test]
fn intercepted_count_starts_at_zero() {
let ctrl = InterceptController::new(true, true);
assert_eq!(ctrl.intercepted_count(), 0);
}
#[test]
fn record_block_concurrent_safe() {
let ctrl = std::sync::Arc::new(InterceptController::new(true, false));
let mut handles = Vec::new();
for _ in 0..4 {
let c = std::sync::Arc::clone(&ctrl);
handles.push(std::thread::spawn(move || {
for _ in 0..100 {
c.record_block();
}
}));
}
for h in handles {
h.join().unwrap();
}
assert_eq!(ctrl.intercepted_count(), 400);
}
#[test]
fn new_with_both_disabled() {
let ctrl = InterceptController::new(false, false);
assert!(!ctrl.block_ads);
assert!(!ctrl.block_media);
assert_eq!(ctrl.intercepted_count(), 0);
}
#[test]
fn new_with_both_enabled() {
let ctrl = InterceptController::new(true, true);
assert!(ctrl.block_ads);
assert!(ctrl.block_media);
}
#[test]
fn disabled_equals_new_false_false() {
let a = InterceptController::disabled();
let b = InterceptController::new(false, false);
assert_eq!(a.block_ads, b.block_ads);
assert_eq!(a.block_media, b.block_media);
}
#[test]
fn default_is_disabled() {
let ctrl = InterceptController::default();
assert!(!ctrl.block_ads);
assert!(!ctrl.block_media);
}
#[test]
fn clone_preserves_config_but_resets_count() {
let ctrl = InterceptController::new(true, true);
ctrl.record_block();
ctrl.record_block();
assert_eq!(ctrl.intercepted_count(), 2);
let cloned = ctrl.clone();
assert!(cloned.block_ads);
assert!(cloned.block_media);
assert_eq!(
cloned.intercepted_count(),
0,
"cloned controller must reset count"
);
}
#[test]
fn block_reason_is_blocked_by_client() {
assert_eq!(BLOCK_REASON, ErrorReason::BlockedByClient);
}
#[test]
fn media_resource_kinds_contains_image_media_font() {
assert!(MEDIA_RESOURCE_KINDS.contains(&ResourceKind::Image));
assert!(MEDIA_RESOURCE_KINDS.contains(&ResourceKind::Media));
assert!(MEDIA_RESOURCE_KINDS.contains(&ResourceKind::Font));
assert_eq!(MEDIA_RESOURCE_KINDS.len(), 3);
}
#[test]
fn end_to_end_doubleclick_pixel_blocked_and_counted() {
let ctrl = InterceptController::new(true, false);
let url = "https://stats.g.doubleclick.net/r/collect?v=1&aip=1";
let should = ctrl.should_block(url, Some(ResourceKind::Image));
assert!(should, "doubleclick pixel must be blocked");
if should {
ctrl.record_block();
}
assert_eq!(ctrl.intercepted_count(), 1);
}
#[test]
fn end_to_end_google_analytics_xhr_blocked() {
let ctrl = InterceptController::new(true, false);
let url = "https://www.google-analytics.com/analytics.js";
let should = ctrl.should_block(url, Some(ResourceKind::Script));
assert!(should);
}
#[test]
fn end_to_end_facebook_pixel_blocked() {
let ctrl = InterceptController::new(true, false);
let url = "https://connect.facebook.net/en_US/fbevents.js";
let should = ctrl.should_block(url, Some(ResourceKind::Script));
assert!(should);
}
#[test]
fn end_to_end_normal_page_resources_pass() {
let ctrl = InterceptController::new(true, true);
assert!(!ctrl.should_block(
"https://example.com/index.html",
Some(ResourceKind::Document)
));
assert!(!ctrl.should_block("https://example.com/app.js", Some(ResourceKind::Script)));
assert!(!ctrl.should_block("https://api.example.com/v1/users", Some(ResourceKind::Xhr)));
}
#[test]
fn end_to_end_business_image_blocked_when_block_media() {
let ctrl = InterceptController::new(false, true);
assert!(ctrl.should_block("https://example.com/product.png", Some(ResourceKind::Image)));
}
#[test]
fn from_resource_type_maps_known_variants() {
assert_eq!(
ResourceKind::from(ResourceType::Document),
ResourceKind::Document
);
assert_eq!(
ResourceKind::from(ResourceType::Script),
ResourceKind::Script
);
assert_eq!(
ResourceKind::from(ResourceType::Stylesheet),
ResourceKind::Stylesheet
);
assert_eq!(ResourceKind::from(ResourceType::Image), ResourceKind::Image);
assert_eq!(ResourceKind::from(ResourceType::Media), ResourceKind::Media);
assert_eq!(ResourceKind::from(ResourceType::Font), ResourceKind::Font);
assert_eq!(ResourceKind::from(ResourceType::Xhr), ResourceKind::Xhr);
assert_eq!(ResourceKind::from(ResourceType::Fetch), ResourceKind::Fetch);
}
#[test]
fn from_resource_type_unknown_maps_to_other() {
let mapped = ResourceKind::from(ResourceType::WebSocket);
assert_eq!(mapped, ResourceKind::Other);
}
#[test]
fn from_resource_type_can_be_used_in_should_block() {
let ctrl = InterceptController::new(false, true);
let cdp_image: ResourceType = ResourceType::Image;
let kind = ResourceKind::from(cdp_image);
assert!(ctrl.should_block_media(Some(kind)));
}
}