Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

test: trim gifs, messages, snowflakes, users, markdown tests

Hampuscac9655155de
diff --git a/fluxer_gifs/Cargo.toml b/fluxer_gifs/Cargo.toml
index 013007b7e..ce8fc4edc 100644
--- a/fluxer_gifs/Cargo.toml
+++ b/fluxer_gifs/Cargo.toml
@@ -20,7 +20,3 @@ tokio = { version = "1.53.1", features = ["macros", "rt-multi-thread", "signal",
tracing = "0.1.44"
url = "2.5"
urlencoding = "2.1"
-
-[dev-dependencies]
-axum = { version = "0.8.9", default-features = false, features = ["http1", "json", "query", "tokio"] }
-tokio = { version = "1.53.1", features = ["net"] }
diff --git a/fluxer_gifs/src/klipy.rs b/fluxer_gifs/src/klipy.rs
index 89e983bbf..e6cb2ee5f 100644
--- a/fluxer_gifs/src/klipy.rs
+++ b/fluxer_gifs/src/klipy.rs
@@ -152,12 +152,6 @@ impl KlipyClient {
})
}
- #[cfg(test)]
- fn with_base_url(mut self, base_url: &str) -> Self {
- self.base_url = base_url.trim_end_matches('/').to_owned();
- self
- }
-
pub async fn search(
&self,
api_key: &str,
@@ -281,8 +275,6 @@ impl KlipyClient {
&self,
api_key: &str,
url: &str,
- _locale: &str,
- _country: &str,
) -> anyhow::Result<Option<GifItem>> {
let Some(path) = parse_klipy_path(url) else {
return Ok(None);
@@ -796,96 +788,6 @@ use fluxer_common::klipy::{ShareKind as KlipyPathType, SharePath as KlipyPath};
mod tests {
use super::*;
- #[tokio::test(flavor = "multi_thread")]
- async fn cold_featured_categories_fit_the_router_shard_budget() {
- use axum::extract::Query;
- use axum::routing::get;
- use std::collections::HashMap;
-
- const UPSTREAM_LATENCY: Duration = Duration::from_millis(200);
-
- let categories = || async {
- sleep(UPSTREAM_LATENCY).await;
- let tags = (0..MAX_FEATURED_CATEGORIES)
- .map(|index| serde_json::json!({"searchterm": format!("term-{index}")}))
- .collect::<Vec<_>>();
- axum::Json(serde_json::json!({ "tags": tags }))
- };
- let search = |Query(params): Query<HashMap<String, String>>| async move {
- sleep(UPSTREAM_LATENCY).await;
- let term = params.get("q").cloned().unwrap_or_default();
- axum::Json(serde_json::json!({
- "results": [{
- "id": term,
- "title": term,
- "itemurl": format!("https://klipy.com/gifs/{term}"),
- "media_formats": {
- "gif": {"url": format!("https://static.klipy.com/{term}.gif"), "dims": [100, 100]}
- }
- }]
- }))
- };
- let app = axum::Router::new()
- .route("/categories", get(categories))
- .route("/search", get(search));
- let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
- .await
- .expect("bind");
- let address = listener.local_addr().expect("local addr");
- tokio::spawn(async move { axum::serve(listener, app).await });
-
- let client = KlipyClient::new(MediaProxyUrlBuilder::new(
- "https://media.example.test",
- "secret",
- ))
- .expect("client")
- .with_base_url(&format!("http://{address}"));
-
- let started = std::time::Instant::now();
- let categories = client
- .featured_categories("key", "sv-SE")
- .await
- .expect("featured categories");
- let elapsed = started.elapsed();
-
- assert_eq!(MAX_FEATURED_CATEGORIES, categories.len());
- assert!(categories.iter().all(|category| !category.src.is_empty()));
- assert_eq!("term-0", categories[0].name);
- assert_eq!(
- format!("term-{}", MAX_FEATURED_CATEGORIES - 1),
- categories[MAX_FEATURED_CATEGORIES - 1].name
- );
- assert!(
- elapsed < fluxer_svc::router::SHARD_REQUEST_TIMEOUT / 2,
- "cold featured categories took {elapsed:?}, the router gives the shard {:?}",
- fluxer_svc::router::SHARD_REQUEST_TIMEOUT
- );
- }
-
- #[test]
- fn resolve_cache_key_ignores_everything_but_the_klipy_path() {
- assert_eq!(
- resolve_cache_key("https://klipy.com/gifs/funny-123"),
- "gifs:funny-123"
- );
- assert_eq!(
- resolve_cache_key("https://www.klipy.com/gif/funny-123?utm_source=x"),
- "gifs:funny-123"
- );
- assert_eq!(
- resolve_cache_key("https://klipy.com/clips/kittens"),
- "clips:kittens"
- );
- assert_ne!(
- resolve_cache_key("https://klipy.com/gifs/kittens"),
- resolve_cache_key("https://klipy.com/clips/kittens")
- );
- assert_eq!(
- resolve_cache_key("https://notklipy.com/gifs/funny"),
- "unresolvable"
- );
- }
-
const FROZEN_PUBLIC_FORMAT_KEYS: [(&str, &str, &str); 16] = [
("hd", "webm", "webm"),
("hd", "mp4", "mp4"),
@@ -916,46 +818,6 @@ mod tests {
}
}
- #[test]
- fn unmapped_sizes_and_formats_produce_no_key() {
- assert_eq!(public_format_key("xxl", "webm"), None);
- assert_eq!(public_format_key("orig", "gif"), None);
- assert_eq!(public_format_key("hd", "avif"), None);
- assert_eq!(public_format_key("", "webm"), None);
- }
-
- #[test]
- fn the_accepted_vocabulary_is_frozen() {
- let mut expected: Vec<&str> = FROZEN_PUBLIC_FORMAT_KEYS
- .iter()
- .map(|(_, _, key)| *key)
- .collect();
- expected.extend(UNSIZED_MEDIA_FORMAT_KEYS);
- expected.sort_unstable();
- let mut ordered = MEDIA_FORMAT_PREFERENCE.to_vec();
- ordered.sort_unstable();
- assert_eq!(
- ordered, expected,
- "preference order must cover exactly the accepted keys"
- );
- for key in expected {
- assert!(is_supported_media_format_key(key), "dropped {key}");
- }
- for key in [
- "preview", "avif", "medium", "hdwebm", "webmm", "tinyavif", "",
- ] {
- assert!(!is_supported_media_format_key(key), "admitted {key}");
- }
- }
-
- #[test]
- fn media_filter_requests_every_accepted_key() {
- assert_eq!(
- MEDIA_FILTER.as_str(),
- "webm,mp4,webp,gif,mediumgif,tinywebm,tinymp4,tinygif,nanowebm,nanomp4,nanogif,loopedmp4,mediummp4,mediumwebm,mediumwebp,nanowebp,tinywebp"
- );
- }
-
#[test]
fn sized_payloads_emit_exactly_the_frozen_key_set() {
let client = KlipyClient::new(MediaProxyUrlBuilder::new(
diff --git a/fluxer_gifs/src/router_impl.rs b/fluxer_gifs/src/router_impl.rs
index 5e55daab1..d4f2af935 100644
--- a/fluxer_gifs/src/router_impl.rs
+++ b/fluxer_gifs/src/router_impl.rs
@@ -88,121 +88,3 @@ fn response_is_cacheable(resp: &GifServiceResponse) -> bool {
| GifServiceResponse::Failed { .. }
)
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn coalesce_key_excludes_api_key() {
- let first = GifRequest::Search {
- api_key: "a".to_owned(),
- q: "wave".to_owned(),
- locale: "en_US".to_owned(),
- country: "US".to_owned(),
- };
- let second = GifRequest::Search {
- api_key: "b".to_owned(),
- q: "wave".to_owned(),
- locale: "en_US".to_owned(),
- country: "US".to_owned(),
- };
-
- assert_eq!(
- GifsRouter::coalesce_key(&first),
- GifsRouter::coalesce_key(&second)
- );
- }
-
- #[test]
- fn trending_key_is_locale_country_scoped_and_api_key_free() {
- let base = GifRequest::GetTrendingGifs {
- api_key: "a".to_owned(),
- locale: "en_US".to_owned(),
- country: "US".to_owned(),
- };
- let different_api_key = GifRequest::GetTrendingGifs {
- api_key: "b".to_owned(),
- locale: "en_US".to_owned(),
- country: "US".to_owned(),
- };
- let different_locale = GifRequest::GetTrendingGifs {
- api_key: "a".to_owned(),
- locale: "sv_SE".to_owned(),
- country: "US".to_owned(),
- };
- let different_country = GifRequest::GetTrendingGifs {
- api_key: "a".to_owned(),
- locale: "en_US".to_owned(),
- country: "SE".to_owned(),
- };
-
- assert_eq!(
- GifsRouter::coalesce_key(&base),
- Some("trending:en_US:US".to_owned())
- );
- assert_eq!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&different_api_key)
- );
- assert_ne!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&different_locale)
- );
- assert_ne!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&different_country)
- );
- assert_eq!(request_l1_key(&base), Some("trending:en_US:US".to_owned()));
- }
-
- #[test]
- fn resolve_key_collapses_locale_country_and_url_spelling() {
- let make = |url: &str, locale: &str, country: &str| GifRequest::ResolveByUrl {
- api_key: "key".to_owned(),
- url: url.to_owned(),
- locale: locale.to_owned(),
- country: country.to_owned(),
- };
- let base = make("https://klipy.com/gifs/kittens", "en_US", "US");
-
- assert_eq!(
- GifsRouter::coalesce_key(&base),
- Some("resolve:gifs:kittens".to_owned())
- );
- assert_eq!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&make("https://klipy.com/gifs/kittens", "sv_SE", "SE"))
- );
- assert_eq!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&make(
- "https://www.klipy.com/gif/kittens?x=1",
- "en_US",
- "US"
- ))
- );
- assert_ne!(
- GifsRouter::coalesce_key(&base),
- GifsRouter::coalesce_key(&make("https://klipy.com/clips/kittens", "en_US", "US"))
- );
- assert_eq!(
- request_l1_key(&base),
- Some("resolve:gifs:kittens".to_owned())
- );
- }
-
- #[test]
- fn register_share_is_not_cached_or_coalesced() {
- let request = GifRequest::RegisterShare {
- api_key: "key".to_owned(),
- id: "gif".to_owned(),
- q: "wave".to_owned(),
- locale: "en_US".to_owned(),
- country: "US".to_owned(),
- };
-
- assert_eq!(GifsRouter::coalesce_key(&request), None);
- assert_eq!(request_l1_key(&request), None);
- }
-}
diff --git a/fluxer_messages/src/mention_extractor.rs b/fluxer_messages/src/mention_extractor.rs
index 2d8b26ebc..790fe0e0c 100644
--- a/fluxer_messages/src/mention_extractor.rs
+++ b/fluxer_messages/src/mention_extractor.rs
@@ -162,200 +162,3 @@ fn url_finder() -> &'static LinkFinder {
finder
})
}
-
-#[cfg(test)]
-mod tests {
- use super::{extract_mentions_from_markdown, may_contain_mention, parse_mentions};
-
- const MENTION_CORPUS: &[&str] = &[
- "hey, are we still on for tonight?",
- "lol",
- "that build is green now, shipping it",
- "no idea, ask in the other channel",
- "brb",
- "https://example.com/some/long/path?query=1&other=2",
- "check out https://github.com/fluxerapp/fluxer/pull/1234 when you get a sec",
- "mail me at [email protected]",
- "the price is 12 <> 15 depending on the region",
- "a < b && c > d",
- "<https://example.com/autolink>",
- "<sms:+15550001111>",
- "<+15550001111>",
- "</settings:123>",
- "<id:customize>",
- "<:custom_emoji:1234567890>",
- "<t:1700000000:R>",
- "```rust\nfn main() { println!(\"hi\"); }\n```",
- "`inline code with a # and an < in it`",
- "**bold** *italic* __underline__ ~~strike~~ ||spoiler||",
- "> quoted line\n> another quoted line",
- "# heading\n## smaller heading\n-# subtext",
- "- item one\n- item two\n1. numbered",
- "|a|b|\n|-|-|\n|1|2|",
- "[masked link](https://example.com)",
- "emoji party πŸŽ‰πŸŽ‰πŸŽ‰ and a flag πŸ‡ΈπŸ‡ͺ",
- "escaped \\<@123> should stay text",
- "escaped \\@everyone should stay text",
- "channel #general is over there",
- "email me @ work tomorrow",
- "@ everyone with a space",
- "@ here with a space",
- "@everyones and @heresy are longer words",
- "hi <@123> <@!456> <@&789> <#321>",
- "<@0> <@&0> <#0>",
- "@everyone hello @here",
- "`@everyone` @here\n```\n@everyone\n```",
- "`<@111>` <@222>\n```txt\n<@333> <#444>\n```\n<#555>",
- "https://example.com/<@123> <@456>",
- "[click here](https://example.com) and <#888> <@999>",
- "**bold <@100>** *italic <@&200>* ~~strike <#300>~~ __underline <@400>__",
- "> quoted <@111>\n<@222>",
- "||spoiler <@333>||",
- "[<@101>](https://example.com/<@202>) <#303>",
- "<@123456789012345678> <@&999> <#888>",
- "<#not_an_id> <@not_an_id> <@&not_an_id>",
- ];
-
- #[test]
- fn prefilter_never_changes_extraction_over_the_corpus() {
- for input in MENTION_CORPUS {
- assert_eq!(
- extract_mentions_from_markdown(Some(input)),
- parse_mentions(input),
- "prefilter changed the result for {input:?}"
- );
- }
- }
-
- #[test]
- fn corpus_exercises_both_prefilter_outcomes() {
- assert!(
- MENTION_CORPUS
- .iter()
- .any(|input| may_contain_mention(input))
- );
- assert!(
- MENTION_CORPUS
- .iter()
- .any(|input| !may_contain_mention(input))
- );
- }
-
- #[test]
- fn prefilter_accepts_every_mention_marker() {
- assert!(may_contain_mention("<@1>"));
- assert!(may_contain_mention("<@!1>"));
- assert!(may_contain_mention("<@&1>"));
- assert!(may_contain_mention("<#1>"));
- assert!(may_contain_mention("@everyone"));
- assert!(may_contain_mention("@here"));
- assert!(!may_contain_mention("< @1>"));
- assert!(!may_contain_mention("@ everyone"));
- assert!(!may_contain_mention("plain text"));
- }
-
- #[test]
- fn extracts_real_user_role_and_channel_mentions() {
- let mentions = extract_mentions_from_markdown(Some("hi <@123> <@!456> <@&789> <#321>"));
- assert!(mentions.users.contains(&123));
- assert!(mentions.users.contains(&456));
- assert!(mentions.roles.contains(&789));
- assert!(mentions.channels.contains(&321));
- }
-
- #[test]
- fn ignores_mentions_inside_inline_and_block_code() {
- let mentions = extract_mentions_from_markdown(Some(
- "`<@111>` <@222>\n```txt\n<@333> <#444>\n```\n<#555>",
- ));
- assert!(!mentions.users.contains(&111));
- assert!(mentions.users.contains(&222));
- assert!(!mentions.users.contains(&333));
- assert!(!mentions.channels.contains(&444));
- assert!(mentions.channels.contains(&555));
- }
-
- #[test]
- fn ignores_mentions_inside_urls() {
- let mentions = extract_mentions_from_markdown(Some("https://example.com/<@123> <@456>"));
- assert!(!mentions.users.contains(&123));
- assert!(mentions.users.contains(&456));
- }
-
- #[test]
- fn detects_everyone_and_here() {
- let mentions = extract_mentions_from_markdown(Some("@everyone hello @here"));
- assert!(mentions.everyone);
- assert!(mentions.here);
- }
-
- #[test]
- fn ignores_everyone_and_here_in_code() {
- let mentions =
- extract_mentions_from_markdown(Some("`@everyone` @here\n```\n@everyone\n```"));
- assert!(!mentions.everyone);
- assert!(mentions.here);
- }
-
- #[test]
- fn extracts_from_nested_formatting() {
- let mentions = extract_mentions_from_markdown(Some(
- "**bold <@100>** *italic <@&200>* ~~strike <#300>~~ __underline <@400>__",
- ));
- assert!(mentions.users.contains(&100));
- assert!(mentions.roles.contains(&200));
- assert!(mentions.channels.contains(&300));
- assert!(mentions.users.contains(&400));
- }
-
- #[test]
- fn extracts_from_blockquotes() {
- let mentions = extract_mentions_from_markdown(Some("> quoted <@111>\n<@222>"));
- assert!(mentions.users.contains(&111));
- assert!(mentions.users.contains(&222));
- }
-
- #[test]
- fn extracts_from_spoilers() {
- let mentions = extract_mentions_from_markdown(Some("||spoiler <@333>||"));
- assert!(mentions.users.contains(&333));
- }
-
- #[test]
- fn returns_empty_for_none_and_empty() {
- assert!(extract_mentions_from_markdown(None).is_empty());
- assert!(extract_mentions_from_markdown(Some("")).is_empty());
- }
-
- #[test]
- fn ignores_zero_id() {
- let mentions = extract_mentions_from_markdown(Some("<@0> <@&0> <#0>"));
- assert!(mentions.users.is_empty());
- assert!(mentions.roles.is_empty());
- assert!(mentions.channels.is_empty());
- }
-
- #[test]
- fn extracts_mention_after_markdown_link() {
- let mentions = extract_mentions_from_markdown(Some(
- "[click here](https://example.com) and <#888> <@999>",
- ));
- assert!(mentions.channels.contains(&888));
- assert!(mentions.users.contains(&999));
- }
-
- #[test]
- fn deduplicates_repeated_mentions() {
- let mentions = extract_mentions_from_markdown(Some("<@100> <@100> <@100> <@&200> <@&200>"));
- assert_eq!(mentions.users.len(), 1);
- assert_eq!(mentions.roles.len(), 1);
- }
- #[test]
- fn markdown_extractor_keeps_link_text_mentions_but_not_url_mentions() {
- let mentions =
- extract_mentions_from_markdown(Some("[<@101>](https://example.com/<@202>) <#303>"));
- assert!(mentions.users.contains(&101));
- assert!(!mentions.users.contains(&202));
- assert!(mentions.channels.contains(&303));
- }
-}
diff --git a/fluxer_snowflakes/src/generator.rs b/fluxer_snowflakes/src/generator.rs
index b13422dc5..6c7ee0662 100644
--- a/fluxer_snowflakes/src/generator.rs
+++ b/fluxer_snowflakes/src/generator.rs
@@ -209,28 +209,6 @@ mod tests {
assert_eq!(parsed.sequence, 77);
}
- #[tokio::test]
- async fn generator_starts_sequence_at_zero() {
- let clock = ManualClock::new(FLUXER_EPOCH_MS + 1000);
- let mut generator = SnowflakeGenerator::with_clock(42, clock).unwrap();
- let id = generator.generate().await.unwrap();
- let parsed = parse_snowflake(id);
- assert_eq!(parsed.timestamp_ms, FLUXER_EPOCH_MS + 1000);
- assert_eq!(parsed.worker_id, 42);
- assert_eq!(parsed.sequence, 0);
- }
-
- #[tokio::test]
- async fn generator_increments_sequence_within_same_millisecond() {
- let clock = ManualClock::new(FLUXER_EPOCH_MS + 1000);
- let mut generator = SnowflakeGenerator::with_clock(7, clock).unwrap();
- let first = parse_snowflake(generator.generate().await.unwrap());
- let second = parse_snowflake(generator.generate().await.unwrap());
- assert_eq!(first.sequence, 0);
- assert_eq!(second.sequence, 1);
- assert_eq!(second.timestamp_ms, first.timestamp_ms);
- }
-
#[tokio::test]
async fn generator_remains_monotonic_when_clock_moves_backwards() {
let clock = ManualClock::new(FLUXER_EPOCH_MS + 1002);
@@ -259,12 +237,4 @@ mod tests {
assert_eq!(parsed.timestamp_ms, FLUXER_EPOCH_MS + 1001);
assert_eq!(parsed.sequence, 0);
}
-
- #[test]
- fn validates_worker_and_sequence_bounds() {
- assert!(create_snowflake(FLUXER_EPOCH_MS, 1023, 4095).is_ok());
- assert!(create_snowflake(FLUXER_EPOCH_MS, 1024, 0).is_err());
- assert!(create_snowflake(FLUXER_EPOCH_MS, 0, 4096).is_err());
- assert!(create_snowflake(FLUXER_EPOCH_MS - 1, 0, 0).is_err());
- }
}
diff --git a/fluxer_snowflakes/src/router_impl.rs b/fluxer_snowflakes/src/router_impl.rs
index 9f965b8b2..50035a7be 100644
--- a/fluxer_snowflakes/src/router_impl.rs
+++ b/fluxer_snowflakes/src/router_impl.rs
@@ -10,44 +10,6 @@ pub struct RoundRobinShardPicker {
shard_count: u32,
}
-impl RoundRobinShardPicker {
- pub fn new(shard_count: u32) -> Self {
- Self {
- next: AtomicU32::new(0),
- shard_count: shard_count.max(1),
- }
- }
-
- pub fn next_shard(&self) -> u32 {
- self.next.fetch_add(1, Ordering::Relaxed) % self.shard_count
- }
-}
-
-pub struct SnowflakeShardPicker {
- round_robin: RoundRobinShardPicker,
- hash_ring: HashRing,
-}
-
-impl SnowflakeShardPicker {
- pub fn new(shard_count: u32) -> Self {
- Self {
- round_robin: RoundRobinShardPicker::new(shard_count),
- hash_ring: HashRing::new(shard_count.max(1)),
- }
- }
-
- pub fn pick_shard(&self, request: &SnowflakeRequest) -> u32 {
- match request.routing_key() {
- Some(routing_key) => self.hash_ring.owner(routing_key),
- None => self.round_robin.next_shard(),
- }
- }
-}
-
-pub struct SnowflakesRouter {
- picker: SnowflakeShardPicker,
-}
-
impl SnowflakesRouter {
pub fn new(shard_count: u32) -> Self {
Self {
@@ -70,49 +32,3 @@ impl RouterService for SnowflakesRouter {
self.picker.pick_shard(request)
}
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn picker_round_robins_across_shards() {
- let picker = RoundRobinShardPicker::new(3);
- let shards = (0..8).map(|_| picker.next_shard()).collect::<Vec<_>>();
- assert_eq!(shards, vec![0, 1, 2, 0, 1, 2, 0, 1]);
- }
-
- #[test]
- fn picker_handles_atomic_wraparound() {
- let picker = RoundRobinShardPicker::new(4);
- picker.next.store(u32::MAX - 1, Ordering::Relaxed);
- let shards = (0..4).map(|_| picker.next_shard()).collect::<Vec<_>>();
- assert_eq!(shards, vec![2, 3, 0, 1]);
- }
-
- #[test]
- fn picker_routes_same_key_to_same_shard() {
- let picker = SnowflakeShardPicker::new(8);
- let request = SnowflakeRequest::GenerateBatch {
- count: 1,
- routing_key: Some("channel:1510189013330296832".to_owned()),
- };
- let first = picker.pick_shard(&request);
- for _ in 0..100 {
- assert_eq!(picker.pick_shard(&request), first);
- }
- }
-
- #[test]
- fn picker_round_robins_unrouted_requests() {
- let picker = SnowflakeShardPicker::new(3);
- let request = SnowflakeRequest::GenerateBatch {
- count: 1,
- routing_key: None,
- };
- let shards = (0..8)
- .map(|_| picker.pick_shard(&request))
- .collect::<Vec<_>>();
- assert_eq!(shards, vec![0, 1, 2, 0, 1, 2, 0, 1]);
- }
-}
diff --git a/fluxer_snowflakes/src/shard_impl.rs b/fluxer_snowflakes/src/shard_impl.rs
index d21013d1e..1aa917349 100644
--- a/fluxer_snowflakes/src/shard_impl.rs
+++ b/fluxer_snowflakes/src/shard_impl.rs
@@ -50,58 +50,3 @@ impl ShardService for SnowflakesShard {
}
}
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::generator::parse_snowflake;
-
- #[tokio::test]
- async fn shard_generates_requested_batch() {
- let shard = SnowflakesShard::new(12).unwrap();
- let response = shard
- .handle(SnowflakeRequest::GenerateBatch {
- count: 8,
- routing_key: None,
- })
- .await
- .unwrap();
- assert_eq!(response.ids.len(), 8);
- let mut previous = 0;
- for id in response.ids {
- let parsed_id = id.parse::<u64>().unwrap();
- assert!(parsed_id > previous);
- assert_eq!(parse_snowflake(parsed_id).worker_id, 12);
- previous = parsed_id;
- }
- }
-
- #[tokio::test]
- async fn shard_rejects_empty_and_oversized_batches() {
- let shard = SnowflakesShard::new(0).unwrap();
- assert!(
- shard
- .handle(SnowflakeRequest::GenerateBatch {
- count: 0,
- routing_key: None,
- })
- .await
- .is_err()
- );
- assert!(
- shard
- .handle(SnowflakeRequest::GenerateBatch {
- count: MAX_BATCH_SIZE + 1,
- routing_key: None,
- })
- .await
- .is_err()
- );
- }
-
- #[test]
- fn shard_id_must_fit_worker_bits() {
- assert!(SnowflakesShard::new(MAX_WORKER_ID).is_ok());
- assert!(SnowflakesShard::new(MAX_WORKER_ID + 1).is_err());
- }
-}
diff --git a/fluxer_users/src/pseudonym.rs b/fluxer_users/src/pseudonym.rs
index 6e140051c..67d6f7d39 100644
--- a/fluxer_users/src/pseudonym.rs
+++ b/fluxer_users/src/pseudonym.rs
@@ -183,62 +183,6 @@ mod tests {
}
}
- #[test]
- fn shares_the_reserved_list_and_development_secret() {
- let fixture = fixture();
- let reserved = fixture["reserved_discriminators"]
- .as_array()
- .expect("a reserved list")
- .iter()
- .map(|value| value.as_u64().expect("a number") as u32)
- .collect::<Vec<_>>();
- assert_eq!(reserved, RESERVED_DISCRIMINATORS.to_vec());
- assert_eq!(fixture["development_secret"], DEVELOPMENT_SECRET);
- }
-
- #[test]
- fn is_stable_per_account_and_differs_across_accounts() {
- let secret = b"stable-secret";
- let first = pseudonym_with_secret(secret, 1_174_109_840_998_400_001);
- assert_eq!(
- first,
- pseudonym_with_secret(secret, 1_174_109_840_998_400_001)
- );
- let names = (0..200)
- .map(|offset| pseudonym_with_secret(secret, 1_174_109_840_998_400_001 + offset))
- .collect::<std::collections::HashSet<_>>();
- assert_eq!(names.len(), 200);
- assert_ne!(
- first,
- pseudonym_with_secret(b"other-secret", 1_174_109_840_998_400_001)
- );
- }
-
- #[test]
- fn looks_like_a_generated_account() {
- for user_id in 0..500 {
- let generated = pseudonym_with_secret(b"format-secret", user_id);
- assert!(
- is_valid_username(&generated.username),
- "{}",
- generated.username
- );
- assert!(
- SCALES.iter().any(|scale| {
- generated
- .username
- .strip_prefix(&capitalize(scale))
- .is_some_and(|rest| TAILS.iter().any(|tail| rest == capitalize(tail)))
- }),
- "{}",
- generated.username
- );
- let discriminator = generated.discriminator as u32;
- assert!((1..=MAX_DISCRIMINATOR).contains(&discriminator));
- assert!(!RESERVED_DISCRIMINATORS.contains(&discriminator));
- }
- }
-
#[test]
fn configuration_requires_a_secret_outside_development() {
assert!(configure(None, None).is_err());
diff --git a/packages/markdown_parser/rust/Cargo.toml b/packages/markdown_parser/rust/Cargo.toml
index c89e40e2f..39d39da41 100644
--- a/packages/markdown_parser/rust/Cargo.toml
+++ b/packages/markdown_parser/rust/Cargo.toml
@@ -18,4 +18,3 @@ serde_json = "1.0"
[dev-dependencies]
criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support"] }
-proptest = "1.11"
diff --git a/packages/markdown_parser/rust/src/links.rs b/packages/markdown_parser/rust/src/links.rs
index 810779649..5fd1f9583 100644
--- a/packages/markdown_parser/rust/src/links.rs
+++ b/packages/markdown_parser/rust/src/links.rs
@@ -1400,77 +1400,3 @@ pub fn count_repeated_byte(text: &str, position: usize, byte: u8) -> usize {
}
count
}
-
-#[cfg(test)]
-mod tests {
- use super::{extract_escaped_url, has_valid_code_fence_language};
-
- #[test]
- fn escaped_url_accepts_paren_immediately_after_destination() {
- let info = extract_escaped_url("https://example.com>) trailing", 0).expect("valid");
- assert_eq!(info.url, "https://example.com");
- assert!(info.escaped);
- assert_eq!(info.advance_by, "https://example.com>)".len());
- }
-
- #[test]
- fn escaped_url_rejects_content_between_destination_and_paren() {
- assert!(extract_escaped_url("https://example.com> and more)", 0).is_none());
- assert!(extract_escaped_url("https://example.com> )", 0).is_none());
- assert!(extract_escaped_url("https://example.com>text)", 0).is_none());
- }
-
- #[test]
- fn escaped_url_rejects_missing_paren() {
- assert!(extract_escaped_url("https://example.com>", 0).is_none());
- assert!(extract_escaped_url("https://example.com", 0).is_none());
- }
-
- #[test]
- fn escaped_url_keeps_paren_inside_destination() {
- let info = extract_escaped_url("https://example.com/a.yaml)>)", 0).expect("valid");
- assert_eq!(info.url, "https://example.com/a.yaml)");
- }
-
- #[test]
- fn rejects_leading_whitespace() {
- assert!(!has_valid_code_fence_language(" hello"));
- assert!(!has_valid_code_fence_language("\thello"));
- assert!(!has_valid_code_fence_language(" rust"));
- assert!(!has_valid_code_fence_language(" js code"));
- }
-
- #[test]
- fn rejects_empty_and_whitespace_only() {
- assert!(!has_valid_code_fence_language(""));
- assert!(!has_valid_code_fence_language(" "));
- assert!(!has_valid_code_fence_language(" "));
- assert!(!has_valid_code_fence_language("\t"));
- }
-
- #[test]
- fn accepts_single_token_languages() {
- assert!(has_valid_code_fence_language("rust"));
- assert!(has_valid_code_fence_language("js"));
- assert!(has_valid_code_fence_language("c#"));
- assert!(has_valid_code_fence_language("c++"));
- assert!(has_valid_code_fence_language("objective-c"));
- assert!(has_valid_code_fence_language("rust "));
- }
-
- #[test]
- fn rejects_unknown_multi_token_info_strings() {
- assert!(!has_valid_code_fence_language("hello world"));
- }
-
- #[test]
- fn accepts_known_multi_token_languages() {
- assert!(has_valid_code_fence_language("js code"));
- }
-
- #[test]
- fn rejects_invalid_characters_in_primary_token() {
- assert!(!has_valid_code_fence_language("a!b"));
- assert!(!has_valid_code_fence_language("rust!"));
- }
-}
diff --git a/packages/markdown_parser/rust/src/plaintext.rs b/packages/markdown_parser/rust/src/plaintext.rs
index b1ab679c5..cb1c0d1ef 100644
--- a/packages/markdown_parser/rust/src/plaintext.rs
+++ b/packages/markdown_parser/rust/src/plaintext.rs
@@ -43,10 +43,6 @@ pub fn parse_and_render_plaintext(
Ok(render_ast_to_plaintext(&nodes, options))
}
-pub fn render_ast_to_plaintext(nodes: &[Node], options: &PlaintextOptions) -> String {
- render_to_plaintext(nodes, options)
-}
-
fn is_block_node(node: &Node) -> bool {
matches!(
node,
@@ -360,10 +356,6 @@ fn render_alert_label(alert_type: AlertType) -> &'static str {
}
}
-fn alert_type_name(alert_type: AlertType) -> &'static str {
- render_alert_label(alert_type)
-}
-
fn render_mention_to_plaintext(kind: &MentionKind, options: &PlaintextOptions) -> String {
match kind {
MentionKind::User { id } => options
@@ -532,49 +524,3 @@ fn collapse_excess_newlines(value: &str) -> String {
fn trim_newlines(value: &str) -> String {
value.trim_matches('\n').to_owned()
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::ast::ParserFlags;
-
- #[test]
- fn preserves_notification_markdown_and_resolves_mentions() {
- let mut users = HashMap::new();
- users.insert("1".to_owned(), "Alice".to_owned());
- let mut roles = HashMap::new();
- roles.insert("2".to_owned(), "Ops".to_owned());
- let mut channels = HashMap::new();
- channels.insert("3".to_owned(), "alerts".to_owned());
- let options = PlaintextOptions {
- preserve_markdown: true,
- users,
- roles,
- channels,
- ..PlaintextOptions::default()
- };
-
- let result = parse_and_render_plaintext(
- "**hi** <@1> <@&2> <#3> [site](https://fluxer.app)",
- ParserFlags::ALL,
- "",
- &options,
- )
- .unwrap();
-
- assert_eq!(
- result,
- "**hi** @Alice @Ops #alerts [site](https://fluxer.app)"
- );
-
- let empty_blockquote_result = parse_and_render_plaintext(
- "> \n> \nsome text",
- ParserFlags::ALLOW_BLOCKQUOTES,
- "",
- &options,
- )
- .unwrap();
-
- assert_eq!(empty_blockquote_result, "> \n> \nsome text");
- }
-}
diff --git a/packages/markdown_parser/rust/tests/code_blocks.rs b/packages/markdown_parser/rust/tests/code_blocks.rs
deleted file mode 100644
index 6c7af579f..000000000
--- a/packages/markdown_parser/rust/tests/code_blocks.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use fluxer_markdown_parser::{EmojiContext, MarkdownParser, ParserFlags};
-use serde_json::json;
-
-fn parse(input: &str) -> serde_json::Value {
- let mut parser = MarkdownParser::new(ParserFlags::ALLOW_CODE_BLOCKS, EmojiContext::default());
- let nodes = parser.parse(input).expect("parse succeeds");
- serde_json::to_value(nodes).expect("serialize succeeds")
-}
-
-#[test]
-fn space_after_fence_keeps_following_lines() {
- assert_eq!(
- parse("``` hello\nworld\n```"),
- json!([{"type":"CodeBlock","content":" hello\nworld\n"}])
- );
-}
-
-#[test]
-fn bare_fence_has_no_language() {
- assert_eq!(
- parse("```\nfoo\n```"),
- json!([{"type":"CodeBlock","content":"foo\n"}])
- );
-}
-
-#[test]
-fn single_line_fence_with_space_is_content() {
- assert_eq!(
- parse("``` hello```"),
- json!([{"type":"CodeBlock","content":" hello"}])
- );
-}
-
-#[test]
-fn single_line_fence_without_space_is_content() {
- assert_eq!(
- parse("```hello```"),
- json!([{"type":"CodeBlock","content":"hello"}])
- );
-}
-
-#[test]
-fn fence_after_a_preceding_line_opens_code_block() {
- assert_eq!(
- parse("intro line\nlabel```rust\nfn main() {}\n```"),
- json!([
- {"type": "Text", "content": "intro line\nlabel"},
- {"type": "CodeBlock", "language": "rust", "content": "fn main() {}\n"}
- ])
- );
-}
-
-#[test]
-fn fenced_body_with_pipes_after_a_line_is_not_a_table() {
- assert_eq!(
- parse("heading text\nrow```md\na | b\n---\nc | d\n```"),
- json!([
- {"type": "Text", "content": "heading text\nrow"},
- {"type": "CodeBlock", "language": "md", "content": "a | b\n---\nc | d\n"}
- ])
- );
-}
-
-#[test]
-fn unterminated_midline_fence_after_a_line_stays_text() {
- assert_eq!(
- parse("hello\nfoo```bar with no closing fence"),
- json!([{"type": "Text", "content": "hello\nfoo```bar with no closing fence"}])
- );
-}
-
-#[test]
-fn escaped_fence_stays_text_on_one_line() {
- assert_eq!(
- parse("\\```hello```"),
- json!([{"type": "Text", "content": "```hello```"}])
- );
-}
-
-#[test]
-fn escaped_fence_stays_text_across_lines() {
- assert_eq!(
- parse("\\```rust\nfn main() {}\n```"),
- json!([{"type": "Text", "content": "```rust\nfn main() {}\n```"}])
- );
-}
-
-#[test]
-fn escaped_midline_fence_stays_text() {
- assert_eq!(
- parse("label\\```rust\nfn main() {}\n```"),
- json!([{"type": "Text", "content": "label```rust\nfn main() {}\n```"}])
- );
-}
-
-#[test]
-fn escaped_backslash_before_fence_still_opens_a_code_block() {
- assert_eq!(
- parse("\\\\```hello```"),
- json!([
- {"type": "Text", "content": "\\"},
- {"type": "CodeBlock", "content": "hello"}
- ])
- );
-}
-
-#[test]
-fn longer_escaped_fence_stays_text() {
- assert_eq!(
- parse("\\````hello````"),
- json!([{"type": "Text", "content": "````hello````"}])
- );
-}
diff --git a/packages/markdown_parser/rust/tests/fixtures.rs b/packages/markdown_parser/rust/tests/fixtures.rs
index bd90209c1..5ab3d637e 100644
--- a/packages/markdown_parser/rust/tests/fixtures.rs
+++ b/packages/markdown_parser/rust/tests/fixtures.rs
@@ -1,7 +1,6 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use fluxer_markdown_parser::{EmojiContext, MarkdownParser, ParserFlags};
-use proptest::prelude::*;
use serde_json::json;
fn parse(input: &str, flags: u32, emoji_context: &str) -> serde_json::Value {
@@ -150,341 +149,3 @@ fn native_parser_fixtures_cover_typescript_suite_surface() {
]})
);
}
-
-#[test]
-fn native_parser_pairs_regional_indicators_with_emoji_context() {
- assert_eq!(
- parse(
- "πŸ‡¦πŸ‡§πŸ‡ΈπŸ‡ͺ",
- 0,
- "S\t0\t4\tπŸ‡¦\tregional_indicator_a\t1f1e6\nS\t4\t4\tπŸ‡§\tregional_indicator_b\t1f1e7\nS\t8\t8\tπŸ‡ΈπŸ‡ͺ\tflag_se\t1f1f8-1f1ea\n"
- ),
- json!({"nodes":[
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦","codepoints":"1f1e6","name":"regional_indicator_a"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡§","codepoints":"1f1e7","name":"regional_indicator_b"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡ΈπŸ‡ͺ","codepoints":"1f1f8-1f1ea","name":"flag_se"}}
- ]})
- );
- assert_eq!(
- parse(
- "πŸ‡¦πŸ‡§πŸ‡¦πŸ‡Έ",
- 0,
- "S\t0\t4\tπŸ‡¦\tregional_indicator_a\t1f1e6\nS\t4\t4\tπŸ‡§\tregional_indicator_b\t1f1e7\nS\t8\t8\tπŸ‡¦πŸ‡Έ\tflag_as\t1f1e6-1f1f8\n"
- ),
- json!({"nodes":[
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦","codepoints":"1f1e6","name":"regional_indicator_a"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡§","codepoints":"1f1e7","name":"regional_indicator_b"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦πŸ‡Έ","codepoints":"1f1e6-1f1f8","name":"flag_as"}}
- ]})
- );
- assert_eq!(
- parse("Sark πŸ‡¨πŸ‡Ά", 0, "S\t5\t8\tπŸ‡¨πŸ‡Ά\tflag_sark\t1f1e8-1f1f6\n"),
- json!({"nodes":[
- {"type":"Text","content":"Sark "},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¨πŸ‡Ά","codepoints":"1f1e8-1f1f6","name":"flag_sark"}}
- ]})
- );
- assert_eq!(
- parse("x πŸ‡¦", 0, "S\t2\t4\tπŸ‡¦\tregional_indicator_a\t1f1e6\n"),
- json!({"nodes":[
- {"type":"Text","content":"x "},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦","codepoints":"1f1e6","name":"regional_indicator_a"}}
- ]})
- );
- assert_eq!(
- parse(
- "πŸ‡¦πŸ‡§πŸ‡ΈπŸ‡ͺ",
- 0,
- "S\t0\t4\tπŸ‡¦\tregional_indicator_a\t1f1e6\nS\t4\t8\tπŸ‡§πŸ‡Έ\tflag_bs\t1f1e7-1f1f8\nS\t12\t4\tπŸ‡ͺ\tregional_indicator_e\t1f1ea\n"
- ),
- json!({"nodes":[
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦","codepoints":"1f1e6","name":"regional_indicator_a"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡§","codepoints":"1f1e7","name":"regional_indicator_b"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡ΈπŸ‡ͺ","codepoints":"1f1f8-1f1ea","name":"flag_se"}}
- ]})
- );
- assert_eq!(
- parse("πŸ‡¦πŸ‡§πŸ‡ΈπŸ‡ͺ", 0, ""),
- json!({"nodes":[
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡¦πŸ‡§","codepoints":"1f1e6-1f1e7","name":"flag_ab"}},
- {"type":"Emoji","kind":{"kind":"Standard","raw":"πŸ‡ΈπŸ‡ͺ","codepoints":"1f1f8-1f1ea","name":"flag_se"}}
- ]})
- );
-}
-
-#[test]
-fn native_parser_allows_apostrophe_in_masked_link_destination() {
- let url = "https://docs.example.test/help/faq/#why-can't-this-link-parse%3F";
- let source = format!("[Example resource]({url})");
- let input = r#"A masked link should parse when a URL contains an apostrophe `'` in the fragment: [Example resource](https://docs.example.test/help/faq/#why-can't-this-link-parse%3F)"#;
- assert_eq!(
- parse(input, ParserFlags::ALLOW_MASKED_LINKS, ""),
- json!({"nodes":[
- {"type":"Text","content":"A masked link should parse when a URL contains an apostrophe "},
- {"type":"InlineCode","content":"'"},
- {"type":"Text","content":" in the fragment: "},
- {
- "type":"Link",
- "text":{"type":"Text","content":"Example resource"},
- "url":url,
- "escaped":false,
- "rawUrl":url,
- "source":source
- }
- ]})
- );
-}
-
-#[test]
-fn native_parser_unescapes_numeric_dots_after_masked_link() {
- let input =
- "[`34d2f5e`](https://-/a/commit/-) 1\\.2\\.3\\.4\\.5\\.6\\.7\\.8\\.9\\.10\n \\- Amy";
- assert_eq!(
- parse(input, ParserFlags::ALLOW_MASKED_LINKS, ""),
- json!({"nodes":[
- {
- "type":"Link",
- "text":{"type":"InlineCode","content":"34d2f5e"},
- "url":"https://-/a/commit/-",
- "escaped":false,
- "rawUrl":"https://-/a/commit/-",
- "source":"[`34d2f5e`](https://-/a/commit/-)"
- },
- {"type":"Text","content":" 1.2.3.4.5.6.7.8.9.10\n - Amy"}
- ]})
- );
-}
-
-#[test]
-fn native_parser_unescapes_word_and_sentence_dots() {
- assert_eq!(
- parse("Four more years\\. religion\\.\\.\\.", ParserFlags::ALL, ""),
- json!({"nodes":[
- {"type":"Text","content":"Four more years. religion..."}
- ]})
- );
- assert_eq!(
- parse("C:\\.", ParserFlags::ALL, ""),
- json!({"nodes":[
- {"type":"Text","content":"C:\\."}
- ]})
- );
-}
-
-#[test]
-fn native_parser_allows_app_protocol_links() {
- let flags = ParserFlags::ALLOW_AUTOLINKS | ParserFlags::ALLOW_MASKED_LINKS;
- assert_eq!(
- parse(
- "fluxer://invite/abc fluxer:/channels/123/456 [Open gift](fluxer:gift/xyz)",
- flags,
- ""
- ),
- json!({"nodes":[
- {
- "type":"Link",
- "url":"fluxer://invite/abc",
- "escaped":false,
- "rawUrl":"fluxer://invite/abc",
- "source":"fluxer://invite/abc"
- },
- {"type":"Text","content":" "},
- {
- "type":"Link",
- "url":"fluxer:/channels/123/456",
- "escaped":false,
- "rawUrl":"fluxer:/channels/123/456",
- "source":"fluxer:/channels/123/456"
- },
- {"type":"Text","content":" "},
- {
- "type":"Link",
- "text":{"type":"Text","content":"Open gift"},
- "url":"fluxer:gift/xyz",
- "escaped":false,
- "rawUrl":"fluxer:gift/xyz",
- "source":"[Open gift](fluxer:gift/xyz)"
- }
- ]})
- );
-}
-
-#[test]
-fn native_parser_rejects_apostrophe_in_masked_link_authority() {
- let input = "[Bad](https://ex'ample.com/path)";
- assert_eq!(
- parse(input, ParserFlags::ALLOW_MASKED_LINKS, ""),
- json!({"nodes":[
- {"type":"Text","content":input}
- ]})
- );
-}
-
-#[test]
-fn native_parser_keeps_content_after_unterminated_escaped_destination() {
- let flags = ParserFlags::ALLOW_MASKED_LINKS | ParserFlags::ALLOW_AUTOLINKS;
- assert_eq!(
- parse(
- "a [x](<https://example.com/y)> b [e](<https://example.com/f>)",
- flags,
- ""
- ),
- json!({"nodes":[
- {"type":"Text","content":"a [x]("},
- {"type":"Link","url":"https://example.com/y)","escaped":true,"rawUrl":"https://example.com/y)","source":"<https://example.com/y)>"},
- {"type":"Text","content":" b "},
- {"type":"Link","text":{"type":"Text","content":"e"},"url":"https://example.com/f","escaped":true,"rawUrl":"https://example.com/f","source":"[e](<https://example.com/f>)"}
- ]})
- );
- assert_eq!(
- parse("[bad](<https://example.com/a> )", flags, ""),
- json!({"nodes":[
- {"type":"Text","content":"[bad]("},
- {"type":"Link","url":"https://example.com/a","escaped":true,"rawUrl":"https://example.com/a","source":"<https://example.com/a>"},
- {"type":"Text","content":" )"}
- ]})
- );
-}
-
-#[test]
-fn native_parser_still_accepts_well_formed_escaped_destinations() {
- let flags = ParserFlags::ALLOW_MASKED_LINKS | ParserFlags::ALLOW_AUTOLINKS;
- assert_eq!(
- parse("[ok](<https://example.com/a>)", flags, ""),
- json!({"nodes":[
- {"type":"Link","text":{"type":"Text","content":"ok"},"url":"https://example.com/a","escaped":true,"rawUrl":"https://example.com/a","source":"[ok](<https://example.com/a>)"}
- ]})
- );
-}
-
-#[test]
-fn native_parser_rejects_masked_links_without_visible_text() {
- for input in [
- "[](https://duckduckgo.com)",
- "[ ](https://duckduckgo.com)",
- "[\u{200e} ](<https://duckduckgo.com>)",
- ] {
- assert_eq!(
- parse(input, ParserFlags::ALLOW_MASKED_LINKS, ""),
- json!({"nodes":[
- {"type":"Text","content":input}
- ]})
- );
- }
-}
-
-#[test]
-fn native_parser_requires_visible_subtext_content() {
- assert_eq!(
- parse("-# hello", ParserFlags::ALLOW_SUBTEXT, ""),
- json!({"nodes":[
- {"type":"Subtext","children":[{"type":"Text","content":"hello"}]}
- ]})
- );
- for input in ["-#", "-# ", "-# \t"] {
- assert_eq!(
- parse(input, ParserFlags::ALLOW_SUBTEXT, ""),
- json!({"nodes":[
- {"type":"Text","content":input}
- ]})
- );
- }
- assert_eq!(
- parse(
- "> -#",
- ParserFlags::ALLOW_BLOCKQUOTES | ParserFlags::ALLOW_SUBTEXT,
- ""
- ),
- json!({"nodes":[{
- "type":"Blockquote",
- "children":[{"type":"Text","content":"-#"}]
- }]})
- );
-}
-
-#[test]
-fn native_parser_rejects_formatting_without_visible_content() {
- for input in [
- "` `",
- "`` ``",
- "** **",
- "__ __",
- "~~ ~~",
- "|| ||",
- "`\u{200e}`",
- "~~\u{200e} ~~",
- "# ",
- "||\n||",
- "|| \n||",
- ] {
- assert_eq!(
- parse(input, ParserFlags::ALL, ""),
- json!({"nodes":[
- {"type":"Text","content":input}
- ]})
- );
- }
-}
-
-#[test]
-fn native_parser_rejects_inline_code_across_lines() {
- assert_eq!(
- parse("`\nHello world\n`", ParserFlags::ALL, ""),
- json!({"nodes":[
- {"type":"Text","content":"`\nHello world\n`"}
- ]})
- );
- assert_eq!(
- parse(
- "It seems the new fixes introduced a new bug <:trolley:1435375026174558456> :\n\n`\n.\n`",
- ParserFlags::ALL,
- ""
- ),
- json!({"nodes":[
- {"type":"Text","content":"It seems the new fixes introduced a new bug "},
- {"type":"Emoji","kind":{"kind":"Custom","name":"trolley","id":"1435375026174558456","animated":false}},
- {"type":"Text","content":" :\n\n`\n.\n`"}
- ]})
- );
- assert_eq!(
- parse("one `line` only", ParserFlags::ALL, ""),
- json!({"nodes":[
- {"type":"Text","content":"one "},
- {"type":"InlineCode","content":"line"},
- {"type":"Text","content":" only"}
- ]})
- );
-}
-
-proptest::proptest! {
- #[test]
- fn arbitrary_text_does_not_panic(input in ".{0,4096}") {
- let mut parser = MarkdownParser::new(ParserFlags::ALL, EmojiContext::default());
- let nodes = parser.parse(&input).expect("parse succeeds");
- let serialized = serde_json::to_string(&nodes).expect("serialize succeeds");
- prop_assert!(serialized.starts_with('['));
- }
-}
-
-#[test]
-fn native_parser_starts_a_table_directly_after_a_text_line() {
- let input =
- "intro text\r\n| Framework | Type |\r\n| --------- | ---- |\r\n| React | UI library |";
- let parsed = parse(input, ParserFlags::ALL, "");
- let nodes = parsed["nodes"].as_array().expect("nodes array");
- assert!(
- nodes.iter().any(|node| node["type"] == "Table"),
- "expected a Table node, got {parsed}"
- );
-}
-
-#[test]
-fn native_parser_still_requires_a_delimiter_row_for_a_table() {
- let input = "intro text\n| not | a | table |\njust more text";
- let parsed = parse(input, ParserFlags::ALL, "");
- let nodes = parsed["nodes"].as_array().expect("nodes array");
- assert!(
- !nodes.iter().any(|node| node["type"] == "Table"),
- "pipes alone must not form a table, got {parsed}"
- );
-}
diff --git a/packages/markdown_parser/rust/tests/native_abi.rs b/packages/markdown_parser/rust/tests/native_abi.rs
index c0c4dd8c7..8b4edabe0 100644
--- a/packages/markdown_parser/rust/tests/native_abi.rs
+++ b/packages/markdown_parser/rust/tests/native_abi.rs
@@ -44,15 +44,6 @@ fn parse(input: &str, flags: u32, tsv: &str) -> Result<String, String> {
result
}
-#[test]
-fn parses_formatting_to_json_envelope() {
- let json = parse("**bold**", ParserFlags::ALL, "").expect("parse should succeed");
- assert_eq!(
- json,
- r#"{"nodes":[{"type":"Strong","children":[{"type":"Text","content":"bold"}]}]}"#
- );
-}
-
#[test]
fn matches_wasm_abi_output() {
let input = "# heading\n||spoiler|| <t:1234567890:R>";
@@ -62,32 +53,6 @@ fn matches_wasm_abi_output() {
assert_eq!(native, json);
}
-#[test]
-fn respects_flags() {
- let json = parse("# not a heading", 0, "").expect("parse should succeed");
- assert_eq!(
- json,
- r##"{"nodes":[{"type":"Text","content":"# not a heading"}]}"##
- );
-}
-
-#[test]
-fn uses_emoji_context_records() {
- let json = parse(
- "hi \u{1F600}",
- ParserFlags::ALL,
- "S\t3\t4\t\u{1F600}\tgrinning face\t1f600",
- )
- .expect("parse should succeed");
- assert!(json.contains(r#""name":"grinning face""#), "got: {json}");
-}
-
-#[test]
-fn empty_input_yields_empty_envelope() {
- let json = parse("", ParserFlags::ALL, "").expect("parse should succeed");
- assert_eq!(json, r#"{"nodes":[]}"#);
-}
-
#[test]
fn rejects_invalid_utf8_input() {
let mut out = empty_buffer();