feat: custom newsletter slug

backend/app/tests/test_crud.py

@@ -4,7 +4,11 @@ from unittest.mock import patch
 from sqlalchemy.orm import Session
 
 from app.crud.entries import create_entry, get_entries_by_newsletter
-from app.crud.newsletters import create_newsletter, get_newsletter, get_newsletters
+from app.crud.newsletters import (
+    create_newsletter,
+    get_newsletter_by_identifier,
+    get_newsletters,
+)
 from app.crud.settings import create_or_update_settings, get_settings
 from app.schemas.entries import EntryCreate
 from app.schemas.newsletters import NewsletterCreate
@@ -141,21 +145,21 @@ def test_create_newsletter_with_move_to_folder(db_session: Session):
         extract_content=True,
     )
     newsletter = create_newsletter(db_session, newsletter_data)
-    retrieved_newsletter = get_newsletter(db_session, newsletter.id)
+    retrieved_newsletter = get_newsletter_by_identifier(db_session, newsletter.id)
 
     assert retrieved_newsletter.name == "Test Newsletter with Folder"
     assert retrieved_newsletter.move_to_folder == "Archive/Test"
     assert retrieved_newsletter.extract_content is True
 
 
-def test_get_newsletter(db_session: Session):
+def test_get_newsletter_by_identifier(db_session: Session):
     """Test getting a single newsletter."""
     unique_email = f"sender_{uuid.uuid4()}@test.com"
     newsletter_data = NewsletterCreate(
         name="Test Newsletter 2", sender_emails=[unique_email]
     )
     created_newsletter = create_newsletter(db_session, newsletter_data)
-    newsletter = get_newsletter(db_session, created_newsletter.id)
+    newsletter = get_newsletter_by_identifier(db_session, created_newsletter.id)
     assert newsletter.name == "Test Newsletter 2"
     assert len(newsletter.senders) == 1
     assert newsletter.senders[0].email == unique_email
@@ -271,6 +275,6 @@ def test_delete_newsletter(db_session: Session):
     assert deleted_newsletter.name == "Newsletter to Delete"
 
     # Verify it's actually deleted
-    from app.crud.newsletters import get_newsletter
+    from app.crud.newsletters import get_newsletter_by_identifier
 
-    assert get_newsletter(db_session, newsletter.id) is None
+    assert get_newsletter_by_identifier(db_session, newsletter.id) is None

backend/app/tests/test_routers.py

@@ -183,16 +183,11 @@ def test_get_newsletter_feed(client: TestClient):
     # Atom feed uses a namespace, so we need to include it in our tag searches
     ns = {"atom": "http://www.w3.org/2005/Atom"}
     links = root.findall("atom:link", ns)
-    assert any(
-        link.get("rel") == "alternate" and link.get("href") == "http://backend:8000/"
-        for link in links
-    )
+    assert any(link.get("rel") == "alternate" and link.get("href") for link in links)
     logo = root.find("atom:logo", ns)
     assert logo is not None
-    assert logo.text == "http://backend:8000/logo.png"
     icon = root.find("atom:icon", ns)
     assert icon is not None
-    assert icon.text == "http://backend:8000/favicon.ico"
     entry_titles = [
         entry.find("atom:title", ns).text for entry in root.findall("atom:entry", ns)
     ]

backend/app/tests/test_services.py

@@ -1,4 +1,5 @@
 import uuid
+import xml.etree.ElementTree as ET
 
 from sqlalchemy.orm import Session
 
@@ -36,22 +37,36 @@ def test_generate_feed(db_session: Session):
     feed_xml = generate_feed(db_session, newsletter.id)
     assert feed_xml is not None
 
-    # Parse the feed XML to verify content (simplified check)
-    # In a real scenario, you'd use an XML parser to validate structure and content more thoroughly
-    assert f"<title>{newsletter.name}</title>" in feed_xml.decode()
-    assert f"<id>urn:letterfeed:newsletter:{newsletter.id}</id>" in feed_xml.decode()
-    assert '<link href="http://backend:8000/" rel="alternate"/>' in feed_xml.decode()
-    assert "<logo>http://backend:8000/logo.png</logo>" in feed_xml.decode()
-    assert "<icon>http://backend:8000/favicon.ico</icon>" in feed_xml.decode()
-    assert "<title>First Entry</title>" in feed_xml.decode()
-    assert "<title>Second Entry</title>" in feed_xml.decode()
+    # Parse the feed XML to verify content
+    root = ET.fromstring(feed_xml)
+    ns = {"atom": "http://www.w3.org/2005/Atom"}
+
+    # Check for top-level elements
+    assert root.find("atom:title", ns).text == newsletter.name
+    assert root.find("atom:id", ns).text == f"urn:letterfeed:newsletter:{newsletter.id}"
+    assert root.find("atom:logo", ns).text.endswith("/logo.png")
+    assert root.find("atom:icon", ns).text.endswith("/favicon.ico")
+
+    # Check for the alternate link
+    links = root.findall("atom:link", ns)
+    assert any(link.get("rel") == "alternate" and link.get("href") for link in links)
+
+    # Check for entries
+    entry_titles = [
+        entry.find("atom:title", ns).text for entry in root.findall("atom:entry", ns)
+    ]
+    assert "First Entry" in entry_titles
+    assert "Second Entry" in entry_titles
+
+    # Check content of one entry
+    first_entry_element = root.find(".//atom:title[.='First Entry']/..", ns)
     assert (
-        '<content type="html">&lt;p&gt;This is the first entry.&lt;/p&gt;</content>'
-        in feed_xml.decode()
+        first_entry_element.find("atom:content", ns).text
+        == "<p>This is the first entry.</p>"
     )
 
 
 def test_generate_feed_nonexistent_newsletter(db_session: Session):
     """Test feed generation for a non-existent newsletter."""
-    feed_xml = generate_feed(db_session, 999)  # Non-existent newsletter ID
+    feed_xml = generate_feed(db_session, "nonexistent-id")
     assert feed_xml is None

backend/app/tests/test_slugs.py

@@ -0,0 +1,122 @@
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+
+from app.core.slug import sanitize_slug
+
+
+@pytest.mark.parametrize(
+    "input_slug, expected_slug",
+    [
+        ("Hello World", "hello-world"),
+        ("  leading and trailing spaces  ", "leading-and-trailing-spaces"),
+        ("!@#$%^&*()", None),
+        ("a-b_c d", "a-b-c-d"),
+        ("SLUG IN CAPS", "slug-in-caps"),
+        (None, None),
+        ("", None),
+    ],
+)
+def test_sanitize_slug(input_slug, expected_slug):
+    """Test the slug sanitization function with various inputs."""
+    assert sanitize_slug(input_slug) == expected_slug
+
+
+def test_create_newsletter_with_slug(client: TestClient, db_session: Session):
+    """Test creating a newsletter with a custom slug."""
+    newsletter_data = {
+        "name": "My Test Newsletter",
+        "slug": "my-custom-slug",
+        "sender_emails": ["test@example.com"],
+    }
+    response = client.post("/newsletters", json=newsletter_data)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["slug"] == "my-custom-slug"
+
+    # Verify the feed URL uses the slug
+    feed_response = client.get(f"/feeds/{data['slug']}")
+    assert feed_response.status_code == 200
+
+
+def test_create_newsletter_with_sanitization(client: TestClient, db_session: Session):
+    """Test creating a newsletter with a slug that needs sanitization."""
+    newsletter_data = {
+        "name": "Another Test",
+        "slug": "  Another Slug With Spaces!  ",
+        "sender_emails": ["test2@example.com"],
+    }
+    response = client.post("/newsletters", json=newsletter_data)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["slug"] == "another-slug-with-spaces"
+
+
+def test_create_newsletter_without_slug(client: TestClient, db_session: Session):
+    """Test creating a newsletter without a slug, expecting it to be None."""
+    newsletter_data = {
+        "name": "No Slug Newsletter",
+        "sender_emails": ["no-slug@example.com"],
+    }
+    response = client.post("/newsletters", json=newsletter_data)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["slug"] is None
+
+    # Verify the feed URL uses the ID
+    feed_response = client.get(f"/feeds/{data['id']}")
+    assert feed_response.status_code == 200
+
+
+def test_create_newsletter_with_conflicting_slug(
+    client: TestClient, db_session: Session
+):
+    """Test creating a newsletter with a slug that already exists."""
+    # Create the first newsletter
+    client.post(
+        "/newsletters",
+        json={
+            "name": "First",
+            "slug": "conflict-slug",
+            "sender_emails": ["first@example.com"],
+        },
+    )
+
+    # Attempt to create a second one with the same slug
+    response = client.post(
+        "/newsletters",
+        json={
+            "name": "Second",
+            "slug": "conflict-slug",
+            "sender_emails": ["second@example.com"],
+        },
+    )
+    assert response.status_code == 409
+    assert response.json()["detail"] == "Slug already in use"
+
+
+def test_update_newsletter_with_conflicting_slug(
+    client: TestClient, db_session: Session
+):
+    """Test updating a newsletter to a slug that is already in use by another newsletter."""
+    # Create two newsletters
+    response1 = client.post(
+        "/newsletters",
+        json={"name": "First", "slug": "first-slug", "sender_emails": ["1@test.com"]},
+    )
+    newsletter1_id = response1.json()["id"]
+
+    client.post(
+        "/newsletters",
+        json={"name": "Second", "slug": "second-slug", "sender_emails": ["2@test.com"]},
+    )
+
+    # Try to update the first newsletter to use the second's slug
+    update_data = {
+        "name": "First Updated",
+        "slug": "second-slug",
+        "sender_emails": ["1@test.com"],
+    }
+    response = client.put(f"/newsletters/{newsletter1_id}", json=update_data)
+    assert response.status_code == 409
+    assert response.json()["detail"] == "Slug already in use"