Merge branch 'ci/add_gitea_workflows' into 'main'

ci: add gitea workflow

See merge request veretcle/oolatoocs!42

.gitea/workflows/check.yml

@@ -0,0 +1,20 @@
+---
+
+name: rust-check
+
+on:  # yamllint disable-line rule:truthy
+  - push
+
+jobs:
+  rust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: "clippy,rustfmt"
+      - run: cargo fmt -- --check
+      - run: cargo check
+      - run: cargo clippy -- -D warnings
+      - run: cargo test
+      - run: cargo build

.gitea/workflows/release.yml

@@ -0,0 +1,23 @@
+---
+
+name: rust-release
+
+on:  # yamllint disable-line rule:truthy
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Get package name
+        run: echo "CARGO_PKG_NAME=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].name')" >> $GITEA_ENV
+      - run: cargo build --release
+      - uses: https://gitea.com/actions/gitea-release-action@v1
+        with:
+          files: |-
+            target/release/${{ env.CARGO_PKG_NAME }}
+          api_key: '${{ secrets.RELEASE_TOKEN }}'

.gitignore

@@ -2,3 +2,4 @@
 .last_tweet
 .config.toml
 .config.json
+.bsky.json

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "oolatoocs"
-version = "4.3.1"
+version = "4.5.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -12,7 +12,6 @@ env_logger = "^0.11"
 futures = "^0.3"
 html-escape = "^0.2"
 log = "^0.4"
-megalodon = "^1.0"
 oauth1-request = "^0.6"
 regex = "^1.10"
 reqwest = { version = "^0.12", features = ["json", "stream", "multipart"] }
@@ -24,6 +23,7 @@ bsky-sdk = "^0.1"
 atrium-api = { version = "^0.25", features = ["namespace-appbsky"] }
 image = "^0.25"
 webp = "^0.3"
+megalodon = "^1.1"
 
 [profile.release]
 strip = true

README.md

@@ -16,10 +16,13 @@ Since 2025-01-20, Twitter is now longer supported.
 What it can do:
 * Reproduces the Toot content into the Record;
 * Cuts (poorly) the Toot in half in it’s too long for Bluesky and thread it (this is cut using a word count, not the best method, but it gets the job done);
-* Reuploads images/gifs/videos from Mastodon to Bluesky
+* Reuploads images/gifs/videos/webcards from Mastodon to Bluesky
     * ⚠️ Bluesky does not support mixing images and videos. You can have up to 4 images on a Bsky record **or** 1 video but not mix around. If you do so, only the video will be posted on Bluesky.
     * ⚠️ Bluesky does not support images greater than 1Mb (that is 1,000,000 bytes or 976.6 KiB), so Oolatoocs converts the image to WebP and progressively reduces the quality to fit that limitation.
+    * ⚠️ Bluesky does not support webcards with any other media/quote, so webcards have the last priority
 * Can reproduce threads from Mastodon to Bluesky
+* Can reproduce (self-)quotes from Mastodon to Bluesky
+    * ⚠️ Bluesky can’t do quotes with webcards, you can only embed images **or** a video with quotes
 * ⚠️ Bluesky does support polls for now. So the poll itself is just presented as text from Mastodon instead which is not the most elegant.
 * Can prevent a Toot from being recorded to Bluesky by using the #NoTweet (case-insensitive) hashtag in Mastodon
 

src/bsky.rs

@@ -1,4 +1,4 @@
-use crate::config::BlueskyConfig;
+use crate::{config::BlueskyConfig, utils::convert_aspect_ratio, OolatoocsError};
 use atrium_api::{
     app::bsky::feed::post::RecordData, com::atproto::repo::upload_blob::Output,
     types::string::Datetime, types::string::Language, types::string::RecordKey,
@@ -148,51 +148,27 @@ async fn get_record(
     Ok(record)
 }
 
-/// Generate an embed card record into Bsky
-/// If the preview image does not exist or fails to upload, it is simply ignored
+/// Generate a Union of embed records to be built-in into records
+/// In case an embed cannot be uploaded/created, this calling function silently gets Option instead
+/// of failing
 pub async fn generate_embed_records(
+    config: &BlueskyConfig,
     bsky: &BskyAgent,
-    card: &Card,
-) -> Option<atrium_api::types::Union<atrium_api::app::bsky::feed::post::RecordEmbedRefs>> {
-    // uploads the image card, if it fails, simply ignore everything
-    let blob = if let Some(url) = &card.image {
-        if let Ok(image_blob) = upload_media(true, bsky, url).await {
-            Some(image_blob.blob.clone())
-        } else {
-            None
-        }
-    } else {
-        None
-    };
-
-    let record_card = atrium_api::app::bsky::embed::external::ExternalData {
-        description: card.description.clone(),
-        thumb: blob,
-        title: card.title.clone(),
-        uri: card.url.clone(),
-    };
-
-    Some(atrium_api::types::Union::Refs(
-        atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedExternalMain(Box::new(
-            atrium_api::app::bsky::embed::external::MainData {
-                external: record_card.into(),
-            }
-            .into(),
-        )),
-    ))
-}
-
-/// Generate an array of Bsky media records
-/// As Bsky does not support multiple video in a record or mix of video and images, video has the
-/// highest priority
-pub async fn generate_media_records(
-    bsky: &BskyAgent,
+    qid: Option<&str>,
     media_attach: &[Attachment],
-) -> Option<atrium_api::types::Union<atrium_api::app::bsky::feed::post::RecordEmbedRefs>> {
-    let mut embed: Option<
-        atrium_api::types::Union<atrium_api::app::bsky::feed::post::RecordEmbedRefs>,
-    > = None;
+    card: &Option<Card>,
+) -> Result<
+    Option<atrium_api::types::Union<atrium_api::app::bsky::feed::post::RecordEmbedRefs>>,
+    Box<dyn Error + Send + Sync>,
+> {
+    // handle quote if any
+    let quote_embed = match qid {
+        Some(q) => generate_quote_records(config, q).await.ok(),
+        _ => None,
+    };
 
+    // handle medias if any
+    let media_embed = if media_attach.len() > usize::from(0u8) {
         let image_media_attach: Vec<_> = media_attach
             .iter()
             .filter(|x| x.r#type == AttachmentType::Image)
@@ -204,29 +180,118 @@ pub async fn generate_media_records(
             .cloned()
             .collect();
 
-    // Bsky only tasks 1 video per post, so we’ll try to treat that first and exit
         if !video_media_attach.is_empty() {
-        // treat only the very first video, ignore the rest
-        let media = &video_media_attach[0];
-        let blob = upload_media(false, bsky, &media.url).await.unwrap();
+            generate_video_record(bsky, video_media_attach).await.ok()
+        } else if !image_media_attach.is_empty() {
+            generate_images_records(bsky, image_media_attach).await.ok()
+        } else {
+            return Err(OolatoocsError::new("A media attached is not an image nor a video").into());
+        }
+    } else {
+        None
+    };
 
-        embed = Some(atrium_api::types::Union::Refs(
-            atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedVideoMain(Box::new(
-                atrium_api::app::bsky::embed::video::MainData {
-                    alt: media.description.clone(),
-                    aspect_ratio: None,
-                    captions: None,
-                    video: blob.data.blob,
+    // handle webcard if any
+    let webcard_embed = match card {
+        Some(t) => generate_webcard_records(bsky, t).await.ok(),
+        None => None,
+    };
+
+    if let Some(q) = quote_embed {
+        if let Some(m) = media_embed {
+            let medias_mapped = match m {
+                atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedImagesMain(a) => atrium_api::app::bsky::embed::record_with_media::MainMediaRefs::AppBskyEmbedImagesMain(a),
+                atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedVideoMain(a) => atrium_api::app::bsky::embed::record_with_media::MainMediaRefs::AppBskyEmbedVideoMain(a),
+                _ => return Err(OolatoocsError::new("Something went terribly wrong when trying to add image/video to quote record: can’t decapsulate media").into()),
+            };
+            let quote_mapped = match q {
+                atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedRecordMain(
+                    a,
+                ) => a,
+                _ => return Err(OolatoocsError::new("Something went terribly wrong when trying to add image/video to quote record: can’t decapsulate quote").into()),
+            };
+            Some(atrium_api::types::Union::Refs(
+                atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedRecordWithMediaMain(
+                    Box::new(
+                        atrium_api::app::bsky::embed::record_with_media::MainData {
+                            media: atrium_api::types::Union::Refs(medias_mapped),
+                            record: (*quote_mapped),
+                        }
+                        .into(),
+                    ),
+                ),
+            ))
+        } else {
+            Some(atrium_api::types::Union::Refs(q))
+        }
+    } else if media_embed.is_some() {
+        media_embed.map(atrium_api::types::Union::Refs)
+    } else if webcard_embed.is_some() {
+        webcard_embed.map(atrium_api::types::Union::Refs)
+    } else {
+        None
+    };
+
+    Ok(None)
+}
+
+/// Generate an quote embed record
+/// it is encapsulated in Option to prevent this function from failing
+async fn generate_quote_records(
+    config: &BlueskyConfig,
+    quote_id: &str,
+) -> Result<atrium_api::app::bsky::feed::post::RecordEmbedRefs, Box<dyn Error>> {
+    // if we can’t match the quote_id, simply return None
+    let quote_record = get_record(&config.handle, &rkey(quote_id)).await?;
+
+    Ok(
+        atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedRecordMain(Box::new(
+            atrium_api::app::bsky::embed::record::MainData {
+                record: atrium_api::com::atproto::repo::strong_ref::MainData {
+                    cid: quote_record.data.cid.unwrap(),
+                    uri: quote_record.data.uri.to_owned(),
+                }
+                .into(),
             }
             .into(),
         )),
-        ));
+    )
+}
 
-        // returns immediately, we don’t want to treat the other medias
-        return embed;
+/// Generate an embed webcard record into Bsky
+/// If the preview image does not exist or fails to upload, it is simply ignored
+async fn generate_webcard_records(
+    bsky: &BskyAgent,
+    card: &Card,
+) -> Result<atrium_api::app::bsky::feed::post::RecordEmbedRefs, Box<dyn Error + Send + Sync>> {
+    let blob = match &card.image {
+        Some(url) => upload_media(true, bsky, url).await?.blob.clone().into(),
+        None => None,
+    };
+
+    let record_card = atrium_api::app::bsky::embed::external::ExternalData {
+        description: card.description.clone(),
+        thumb: blob,
+        title: card.title.clone(),
+        uri: card.url.clone(),
+    };
+
+    Ok(
+        atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedExternalMain(Box::new(
+            atrium_api::app::bsky::embed::external::MainData {
+                external: record_card.into(),
             }
+            .into(),
+        )),
+    )
+}
 
-    let mut stream = stream::iter(image_media_attach)
+/// Generate an array of Bsky image media records
+async fn generate_images_records(
+    bsky: &BskyAgent,
+    media_attach: Vec<Attachment>,
+) -> Result<atrium_api::app::bsky::feed::post::RecordEmbedRefs, Box<dyn Error + Send + Sync>> {
+    let mut stream = stream::iter(media_attach)
         .map(|media| {
             let bsky = bsky.clone();
             tokio::task::spawn(async move {
@@ -237,7 +302,9 @@ pub async fn generate_media_records(
                             .description
                             .clone()
                             .map_or("".to_string(), |v| v.to_owned()),
-                        aspect_ratio: None,
+                        aspect_ratio: convert_aspect_ratio(
+                            &media.meta.as_ref().and_then(|m| m.original.clone()),
+                        ),
                         image: i.data.blob,
                     }
                 })
@@ -256,14 +323,38 @@ pub async fn generate_media_records(
     }
 
     if !images.is_empty() {
-        embed = Some(atrium_api::types::Union::Refs(
+        return Ok(
             atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedImagesMain(Box::new(
                 atrium_api::app::bsky::embed::images::MainData { images }.into(),
             )),
-        ));
+        );
     }
 
-    embed
+    Err(OolatoocsError::new("Cannot embed media").into())
+}
+
+/// Generate a video Bsky media record
+async fn generate_video_record(
+    bsky: &BskyAgent,
+    media_attach: Vec<Attachment>,
+) -> Result<atrium_api::app::bsky::feed::post::RecordEmbedRefs, Box<dyn Error + Send + Sync>> {
+    // treat only the very first video, ignore the rest
+    let media = &media_attach[0];
+    let blob = upload_media(false, bsky, &media.url).await?;
+
+    Ok(
+        atrium_api::app::bsky::feed::post::RecordEmbedRefs::AppBskyEmbedVideoMain(Box::new(
+            atrium_api::app::bsky::embed::video::MainData {
+                alt: media.description.clone(),
+                aspect_ratio: convert_aspect_ratio(
+                    &media.meta.as_ref().and_then(|m| m.original.clone()),
+                ),
+                captions: None,
+                video: blob.data.blob,
+            }
+            .into(),
+        )),
+    )
 }
 
 async fn upload_media(

src/lib.rs

@@ -18,9 +18,7 @@ mod utils;
 use utils::{generate_multi_tweets, strip_everything};
 
 mod bsky;
-use bsky::{
-    build_post_record, generate_embed_records, generate_media_records, get_session, BskyReply,
-};
+use bsky::{build_post_record, generate_embed_records, get_session, BskyReply};
 
 use rusqlite::Connection;
 
@@ -93,7 +91,9 @@ pub async fn run(config: &Config) {
                 true => toot.tags.clone(),
                 false => vec![],
             };
-        let Ok(mut tweet_content) = strip_everything(&toot.content, &toot_tags) else {
+        let Ok(mut tweet_content) =
+            strip_everything(&toot.content, &toot_tags, &config.mastodon.base)
+        else {
             continue; // skip in case we can’t strip something
         };
 
@@ -158,15 +158,24 @@ pub async fn run(config: &Config) {
             });
         };
 
-        // treats medias
-        let mut record_embed = generate_media_records(&bluesky, &toot.media_attachments).await;
+        // get quote_id if any
+        let quote_id = match toot.reblog {
+            Some(r) => match read_state(&conn, Some(r.id.parse::<u64>().unwrap())) {
+                Ok(q) => q.map(|x| x.record_uri.to_owned()),
+                _ => None,
+            },
+            None => None,
+        };
 
-        // treats embed cards if any
-        if let Some(card) = &toot.card {
-            if record_embed.is_none() {
-                record_embed = generate_embed_records(&bluesky, card).await;
-            }
-        }
+        let record_embed = generate_embed_records(
+            &config.bluesky,
+            &bluesky,
+            quote_id.as_deref(),
+            &toot.media_attachments,
+            &toot.card,
+        )
+        .await
+        .unwrap_or_else(|e| panic!("Cannot embed record for {}: {}", &toot.id, e));
 
         // posts corresponding tweet
         let record = build_post_record(

src/mastodon.rs

@@ -1,7 +1,7 @@
 use crate::config::MastodonConfig;
 use chrono::{DateTime, Utc};
 use megalodon::{
-    entities::{Status, StatusVisibility},
+    entities::{QuotedStatus, Status, StatusVisibility},
     generator,
     mastodon::mastodon::Mastodon,
     megalodon::AppInputOptions,
@@ -55,9 +55,19 @@ pub async fn get_mastodon_timeline_since(
                     .clone()
                     .is_some_and(|r| r == t.account.id)
         })
-        .filter(|t| t.visibility == StatusVisibility::Public) // excludes everything that isn’t
-        // public
-        .filter(|t| t.reblog.is_none()) // excludes reblogs
+        .filter(|t| t.visibility == StatusVisibility::Public) // excludes everything that isn’t public
+        .filter(|t| t.reblog.is_none()) // exclude reblogs
+        .filter(|t| {
+            // exclude quotes that aren’t ours
+            t.quote.is_none()
+                || t.quote.clone().is_some_and(|r| match r {
+                    QuotedStatus::Quote(q) => q
+                        .quoted_status
+                        .clone()
+                        .is_some_and(|iq| iq.account.id == t.account.id),
+                    _ => false,
+                })
+        })
         .cloned()
         .collect();
 

src/utils.rs

@@ -1,7 +1,8 @@
+use atrium_api::{app::bsky::embed::defs::AspectRatioData, types::Object};
 use html_escape::decode_html_entities;
-use megalodon::entities::status::Tag;
+use megalodon::entities::{attachment::MetaSub, status::Tag};
 use regex::Regex;
-use std::error::Error;
+use std::{error::Error, num::NonZeroU64};
 
 /// Generate 2 contents out of 1 if that content is > 300 chars, None else
 pub fn generate_multi_tweets(content: &str) -> Option<(String, String)> {
@@ -53,10 +54,16 @@ fn twitter_count(content: &str) -> usize {
     count
 }
 
-pub fn strip_everything(content: &str, tags: &Vec<Tag>) -> Result<String, Box<dyn Error>> {
+pub fn strip_everything(
+    content: &str,
+    tags: &Vec<Tag>,
+    mastodon_base: &str,
+) -> Result<String, Box<dyn Error>> {
     let mut res = strip_html_tags(&content.replace("</p><p>", "\n\n").replace("<br />", "\n"));
 
-    strip_mastodon_tags(&mut res, tags).unwrap();
+    strip_quote_header(&mut res, mastodon_base)?;
+
+    strip_mastodon_tags(&mut res, tags)?;
 
     res = res.trim_end_matches('\n').trim_end_matches(' ').to_string();
     res = decode_html_entities(&res).to_string();
@@ -64,6 +71,16 @@ pub fn strip_everything(content: &str, tags: &Vec<Tag>) -> Result<String, Box<dy
     Ok(res)
 }
 
+fn strip_quote_header(content: &mut String, mastodon_base: &str) -> Result<(), Box<dyn Error>> {
+    let re = Regex::new(&format!(
+        r"^RE: {}\S+\n\n",
+        mastodon_base.replace(".", r"\.")
+    ))?;
+    *content = re.replace(content, "").to_string();
+
+    Ok(())
+}
+
 fn strip_mastodon_tags(content: &mut String, tags: &Vec<Tag>) -> Result<(), Box<dyn Error>> {
     for tag in tags {
         let re = Regex::new(&format!("(?i)(#{} ?)", &tag.name))?;
@@ -94,10 +111,119 @@ fn strip_html_tags(input: &str) -> String {
     data
 }
 
+pub fn convert_aspect_ratio(m: &Option<MetaSub>) -> Option<Object<AspectRatioData>> {
+    match m {
+        Some(ms) => {
+            if ms.height.is_some_and(|x| x > 0) && ms.width.is_some_and(|x| x > 0) {
+                Some(
+                    AspectRatioData {
+                        // unwrap is safe here
+                        height: NonZeroU64::new(ms.height.unwrap().into()).unwrap(),
+                        width: NonZeroU64::new(ms.width.unwrap().into()).unwrap(),
+                    }
+                    .into(),
+                )
+            } else {
+                None
+            }
+        }
+        None => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_convert_aspect_ratio() {
+        // test None orig aspect ratio
+        let metasub: Option<MetaSub> = None;
+
+        let result = convert_aspect_ratio(&metasub);
+
+        assert_eq!(result, None);
+
+        // test complet with image
+        let metasub = Some(MetaSub {
+            width: Some(1920),
+            height: Some(1080),
+            size: Some(String::from("1920x1080")),
+            aspect: Some(1.7777777777777777),
+            frame_rate: None,
+            duration: None,
+            bitrate: None,
+        });
+
+        let expected_result = Some(
+            AspectRatioData {
+                height: NonZeroU64::new(1080).unwrap(),
+                width: NonZeroU64::new(1920).unwrap(),
+            }
+            .into(),
+        );
+
+        let result = convert_aspect_ratio(&metasub);
+
+        assert_eq!(result, expected_result);
+
+        // test complete with video
+        let metasub = Some(MetaSub {
+            width: Some(500),
+            height: Some(278),
+            size: None,
+            aspect: None,
+            frame_rate: Some(String::from("10/1")),
+            duration: Some(0.9),
+            bitrate: Some(973191),
+        });
+
+        let expected_result = Some(
+            AspectRatioData {
+                height: NonZeroU64::new(278).unwrap(),
+                width: NonZeroU64::new(500).unwrap(),
+            }
+            .into(),
+        );
+
+        let result = convert_aspect_ratio(&metasub);
+
+        assert_eq!(result, expected_result);
+
+        /* test broken shit
+         * that should never happened but you never know
+         */
+        // zero width
+        let metasub = Some(MetaSub {
+            width: Some(0),
+            height: Some(278),
+            size: None,
+            aspect: None,
+            frame_rate: Some(String::from("10/1")),
+            duration: Some(0.9),
+            bitrate: Some(973191),
+        });
+
+        let result = convert_aspect_ratio(&metasub);
+
+        assert_eq!(result, None);
+
+        // None height
+        let metasub = Some(MetaSub {
+            width: Some(500),
+            height: None,
+            size: None,
+            aspect: None,
+            frame_rate: Some(String::from("10/1")),
+            duration: Some(0.9),
+            bitrate: Some(973191),
+        });
+
+        let result = convert_aspect_ratio(&metasub);
+
+        assert_eq!(result, None);
+    }
+
     #[test]
     fn test_twitter_count() {
         let content = "tamerelol?! 🐵";
@@ -186,9 +312,19 @@ mod tests {
 
     #[test]
     fn test_strip_everything() {
+        // a classic toot
         let content = "<p>Ce soir à 21h, c&#39;est le Dojobar ! Au programme ce soir, une rétrospective sur la série Mario &amp; Luigi.<br />Comme d&#39;hab, le Twitch sera ici : <a href=\"https://twitch.tv/nintendojofr\" target=\"_blank\" rel=\"nofollow noopener noreferrer\" translate=\"no\"><span class=\"invisible\">https://</span><span class=\"\">twitch.tv/nintendojofr</span><span class=\"invisible\"></span></a><br />Ou juste l&#39;audio là : <a href=\"https://nintendojo.fr/dojobar\" target=\"_blank\" rel=\"nofollow noopener noreferrer\" translate=\"no\"><span class=\"invisible\">https://</span><span class=\"\">nintendojo.fr/dojobar</span><span class=\"invisible\"></span></a><br />A toute !</p>";
         let expected_result = "Ce soir à 21h, c'est le Dojobar ! Au programme ce soir, une rétrospective sur la série Mario & Luigi.\nComme d'hab, le Twitch sera ici : https://twitch.tv/nintendojofr\nOu juste l'audio là : https://nintendojo.fr/dojobar\nA toute !".to_string();
-        let result = strip_everything(content, &vec![]).unwrap();
+        let result = strip_everything(content, &vec![], "https://m.nintendojo.fr").unwrap();
+
+        assert_eq!(result, expected_result);
+
+        // a quoted toot
+        let content = "<p class=\"quote-inline\">RE: <a href=\"https://m.nintendojo.fr/@nintendojofr/115446347351491651\" target=\"_blank\" rel=\"nofollow noopener\" translate=\"no\"><span class=\"invisible\">https://</span><span class=\"ellipsis\">m.nintendojo.fr/@nintendojofr/</span><span class=\"invisible\">115446347351491651</span></a></p><p>Assassin’s Creed Shadows pèsera environ 62,8 Go sur Switch 2 (et un peu plus de 100 Go sur les autres supports), soit tout juste pour rentrer sur une cartouche de 64 Go.</p><p>Ou pas, pour rappel…</p><p><a href=\"https://m.nintendojo.fr/tags/AssassinsCreedShadows\" class=\"mention hashtag\" rel=\"tag\">#<span>AssassinsCreedShadows</span></a> <a href=\"https://m.nintendojo.fr/tags/Ubisoft\" class=\"mention hashtag\" rel=\"tag\">#<span>Ubisoft</span></a> <a href=\"https://m.nintendojo.fr/tags/NintendoSwitch2\" class=\"mention hashtag\" rel=\"tag\">#<span>NintendoSwitch2</span></a></p>";
+
+        let expected_result = "Assassin’s Creed Shadows pèsera environ 62,8 Go sur Switch 2 (et un peu plus de 100 Go sur les autres supports), soit tout juste pour rentrer sur une cartouche de 64 Go.\n\nOu pas, pour rappel…\n\n#AssassinsCreedShadows #Ubisoft #NintendoSwitch2";
+
+        let result = strip_everything(content, &vec![], "https://m.nintendojo.fr").unwrap();
 
         assert_eq!(result, expected_result);
     }