544 lines
24 KiB
Python
544 lines
24 KiB
Python
"""End-to-end tests: a real server, talking to a real (stand-in) FreshRSS.
|
|
|
|
These run the whole stack rather than units of it: the configuration is loaded
|
|
through its validation path, the HTTP server serves on a socket, the FreshRSS
|
|
client speaks HTTP to the stub, and the EPUB that comes back is opened and
|
|
checked. The claim that matters most -- that downloading a book marks the
|
|
matching article read upstream, and only a completed download does -- can only be
|
|
verified here, by looking at what the stub received.
|
|
|
|
Image embedding is turned off in this configuration so the suite stays offline;
|
|
image handling has its own tests with a stand-in fetcher.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import unittest
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
import zipfile
|
|
from io import BytesIO
|
|
from pathlib import Path
|
|
|
|
from app import server as app_server
|
|
from app.config import load_config, password_digest
|
|
from app.epub import ARTICLE_PATH, OPF_PATH
|
|
from tests.stub_freshrss import READING_LIST, build_demo_catalog, item_id
|
|
from tests.support import parse_xml
|
|
|
|
|
|
class _NoRedirects(urllib.request.HTTPRedirectHandler):
|
|
"""Surface a redirect as its own status instead of following it.
|
|
|
|
urlopen follows redirects transparently, so a test that asserts on a 302 would
|
|
otherwise be looking at the status of whatever the redirect pointed at.
|
|
"""
|
|
|
|
def redirect_request(self, req, fp, code, msg, headers, newurl):
|
|
return None
|
|
|
|
|
|
USERNAME = "reader"
|
|
PASSWORD = "reader-password"
|
|
TECH_FEED = "feed/https://example.com/tech/atom.xml"
|
|
|
|
|
|
class ServerTestCase(unittest.TestCase):
|
|
"""Starts a stub FreshRSS and the real server for each test."""
|
|
|
|
include_images = False
|
|
|
|
def setUp(self):
|
|
self.stub = build_demo_catalog().start()
|
|
self.addCleanup(self.stub.stop)
|
|
# The demo account ships one already-read article, so assertions about
|
|
# marking read are written against the change, not the absolute state.
|
|
self.baseline_read = set(self.stub.read)
|
|
self._dir = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self._dir.cleanup)
|
|
self._no_redirects = urllib.request.build_opener(_NoRedirects)
|
|
self.config = self._write_config()
|
|
self.httpd, self.application = app_server.build_server(self.config)
|
|
self.port = self.httpd.server_address[1]
|
|
self.thread = threading.Thread(
|
|
target=self.httpd.serve_forever, kwargs={"poll_interval": 0.02}, daemon=True
|
|
)
|
|
self.thread.start()
|
|
self.addCleanup(self._stop_server)
|
|
|
|
def _stop_server(self):
|
|
self.httpd.shutdown()
|
|
self.httpd.server_close()
|
|
self.thread.join(timeout=5)
|
|
|
|
@property
|
|
def base(self) -> str:
|
|
return f"http://127.0.0.1:{self.port}"
|
|
|
|
def _write_config(self):
|
|
document = {
|
|
"server": {"host": "127.0.0.1", "port": 0, "log_level": "critical"},
|
|
"freshrss": {
|
|
"url": self.stub.api_url,
|
|
"username": self.stub.username,
|
|
"api_password": self.stub.password,
|
|
"items_per_page": 2,
|
|
"timeout_seconds": 5,
|
|
"retries": 0,
|
|
},
|
|
"catalog": {"title": "Test Catalog", "author": "Tester"},
|
|
"epub": {"include_images": self.include_images},
|
|
"auth": {
|
|
"users": [{"username": USERNAME, "password_sha256": password_digest(PASSWORD)}]
|
|
},
|
|
"cache": {"subscriptions_ttl_seconds": 1, "stream_ttl_seconds": 1},
|
|
}
|
|
path = Path(self._dir.name) / "config.json"
|
|
path.write_text(json.dumps(document), encoding="utf-8")
|
|
return load_config(str(path))
|
|
|
|
# -- HTTP helpers ----------------------------------------------------
|
|
|
|
def request(self, path, *, auth=True, method="GET", headers=None, follow_redirects=True):
|
|
request = urllib.request.Request(self.base + path, method=method)
|
|
if auth:
|
|
token = base64.b64encode(f"{USERNAME}:{PASSWORD}".encode()).decode()
|
|
request.add_header("Authorization", f"Basic {token}")
|
|
for key, value in (headers or {}).items():
|
|
request.add_header(key, value)
|
|
opener = urllib.request.urlopen if follow_redirects else self._no_redirects.open
|
|
try:
|
|
with opener(request, timeout=10) as response:
|
|
return response.status, dict(response.headers), response.read()
|
|
except urllib.error.HTTPError as error:
|
|
# With redirects suppressed, a 3xx arrives here, which is the point.
|
|
# The error object owns the response socket, so it is closed rather
|
|
# than left for the garbage collector.
|
|
try:
|
|
body = error.read()
|
|
finally:
|
|
error.close()
|
|
return error.code, dict(error.headers), body
|
|
|
|
def wait_for_mark_read(self, expected: set[str], timeout: float = 5.0) -> set[str]:
|
|
"""Wait for a mark-read to land upstream (returns what landed).
|
|
|
|
The server marks an article read only after the body has been delivered,
|
|
so from the client's side that upstream effect is asynchronous: a test
|
|
asserting immediately would be racing the handler thread. It is
|
|
deliberately not the other way round -- marking before delivery would
|
|
consume articles whose transfer failed.
|
|
"""
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
landed = self.stub.read - self.baseline_read
|
|
if landed >= expected:
|
|
return landed
|
|
time.sleep(0.02)
|
|
return self.stub.read - self.baseline_read
|
|
|
|
def get_xml(self, path, *, auth=True):
|
|
status, headers, body = self.request(path, auth=auth)
|
|
self.assertEqual(status, 200, body[:400])
|
|
node = parse_xml(body)
|
|
return node, headers
|
|
|
|
def entries(self, node):
|
|
return {entry.must_find("title").all_text(): entry for entry in node.must_find_all("entry")}
|
|
|
|
def follow(self, entry, rel: str) -> str:
|
|
for link in entry.must_find_all("link"):
|
|
if link.attr("rel") == rel:
|
|
return link.must_attr("href")
|
|
raise AssertionError(f"no {rel!r} link in entry")
|
|
|
|
def acquisition_path(self, section="unread", label="Tech", feed_title="Example Tech") -> str:
|
|
"""Walk the catalog down to one feed's acquisition feed.
|
|
|
|
Shared by the suite rather than owned by one test class: the download,
|
|
pagination, search and serialisation tests all start from a feed.
|
|
"""
|
|
node, _ = self.get_xml(f"/opds/{section}")
|
|
category = self.follow(self.entries(node)[label], "subsection")
|
|
node, _ = self.get_xml(urllib.parse.urlsplit(category).path)
|
|
return urllib.parse.urlsplit(self.follow(self.entries(node)[feed_title], "subsection")).path
|
|
|
|
def download_path(self, title="A Tech Post & Its Friends", section="unread") -> str:
|
|
"""The EPUB acquisition URL for one article."""
|
|
node, _ = self.get_xml(self.acquisition_path(section=section))
|
|
entry = self.entries(node)[title]
|
|
return urllib.parse.urlsplit(
|
|
self.follow(entry, "http://opds-spec.org/acquisition/open-access")
|
|
).path
|
|
|
|
|
|
class AuthenticationTests(ServerTestCase):
|
|
def test_catalog_requires_credentials(self):
|
|
status, headers, _body = self.request("/opds", auth=False)
|
|
self.assertEqual(status, 401)
|
|
self.assertIn("Basic", headers.get("WWW-Authenticate", ""))
|
|
self.assertIn("Test" if False else "OPDS", headers.get("WWW-Authenticate", ""))
|
|
|
|
def test_wrong_password_is_rejected(self):
|
|
token = base64.b64encode(f"{USERNAME}:wrong".encode()).decode()
|
|
status, _headers, _body = self.request(
|
|
"/opds", auth=False, headers={"Authorization": f"Basic {token}"}
|
|
)
|
|
self.assertEqual(status, 401)
|
|
|
|
def test_health_needs_no_credentials_and_touches_nothing(self):
|
|
status, _headers, body = self.request("/healthz", auth=False)
|
|
self.assertEqual(status, 200)
|
|
self.assertEqual(json.loads(body), {"status": "ok"})
|
|
self.assertEqual(self.stub.requests, [])
|
|
|
|
def test_malformed_authorization_header_is_rejected(self):
|
|
for value in ("Basic", "Bearer xyz", "Basic !!!not-base64", "Basic " + "aGk="):
|
|
with self.subTest(value=value):
|
|
status, _headers, _body = self.request(
|
|
"/opds", auth=False, headers={"Authorization": value}
|
|
)
|
|
self.assertEqual(status, 401)
|
|
|
|
def test_diagnostics_requires_credentials(self):
|
|
self.assertEqual(self.request("/opds/healthz", auth=False)[0], 401)
|
|
|
|
def test_diagnostics_reports_upstream_state(self):
|
|
status, _headers, body = self.request("/opds/healthz")
|
|
self.assertEqual(status, 200)
|
|
payload = json.loads(body)
|
|
self.assertTrue(payload["upstream"]["reachable"])
|
|
self.assertEqual(payload["catalog"]["feeds"], 3)
|
|
self.assertTrue(payload["mark_read"])
|
|
|
|
|
|
class NavigationTests(ServerTestCase):
|
|
def test_bare_root_redirects_to_the_catalog(self):
|
|
# Redirects must be suppressed, or this would see the 401 that /opds
|
|
# answers an unauthenticated follower with.
|
|
status, headers, _body = self.request("/", auth=False, follow_redirects=False)
|
|
self.assertEqual(status, 302)
|
|
self.assertTrue(headers["Location"].endswith("/opds"))
|
|
|
|
def test_root_lists_the_sections(self):
|
|
node, headers = self.get_xml("/opds")
|
|
self.assertEqual(node.must_find("title").all_text(), "Test Catalog")
|
|
titles = set(self.entries(node))
|
|
self.assertIn("Unread", titles)
|
|
self.assertIn("Read", titles)
|
|
self.assertIn("Starred", titles)
|
|
|
|
def test_navigation_feed_declares_its_profile(self):
|
|
_node, headers = self.get_xml("/opds")
|
|
self.assertEqual(
|
|
headers["Content-Type"],
|
|
"application/atom+xml;profile=opds-catalog;kind=navigation",
|
|
)
|
|
|
|
def test_root_offers_a_search_link(self):
|
|
node, _headers = self.get_xml("/opds")
|
|
rels = {link.attr("rel") for link in node.must_find_all("link")}
|
|
self.assertIn("search", rels)
|
|
self.assertIn("self", rels)
|
|
|
|
def test_section_lists_categories_with_unread_counts(self):
|
|
node, _headers = self.get_xml("/opds/unread")
|
|
entries = self.entries(node)
|
|
self.assertIn("Tech", entries)
|
|
self.assertIn("News", entries)
|
|
self.assertIn("Uncategorised", entries)
|
|
self.assertIn("unread", entries["Tech"].must_find("content").all_text())
|
|
|
|
def test_category_lists_its_feeds(self):
|
|
category = self.follow(self.entries(self.get_xml("/opds/unread")[0])["Tech"], "subsection")
|
|
node, _headers = self.get_xml(urllib.parse.urlsplit(category).path)
|
|
titles = set(self.entries(node))
|
|
self.assertIn("Example Tech", titles)
|
|
self.assertIn("All in this category", titles)
|
|
|
|
def test_unknown_path_is_404(self):
|
|
self.assertEqual(self.request("/opds/nope")[0], 404)
|
|
|
|
def test_undecodable_identifier_is_404(self):
|
|
self.assertEqual(self.request("/opds/unread/c/!!!not-base64")[0], 404)
|
|
|
|
def test_post_is_not_allowed(self):
|
|
self.assertEqual(self.request("/opds", method="POST")[0], 405)
|
|
|
|
def test_opensearch_descriptor_is_served(self):
|
|
node, headers = self.get_xml("/opds/opensearch.xml")
|
|
self.assertEqual(headers["Content-Type"], "application/opensearchdescription+xml")
|
|
url = node.must_find("Url")
|
|
self.assertIn("searchTerms", url.must_attr("template"))
|
|
|
|
|
|
class AcquisitionTests(ServerTestCase):
|
|
def test_acquisition_feed_lists_articles(self):
|
|
node, headers = self.get_xml(self.acquisition_path())
|
|
self.assertEqual(
|
|
headers["Content-Type"],
|
|
"application/atom+xml;profile=opds-catalog;kind=acquisition",
|
|
)
|
|
titles = set(self.entries(node))
|
|
self.assertIn("A Tech Post & Its Friends", titles)
|
|
|
|
def test_read_articles_are_absent_from_the_unread_feed(self):
|
|
titles = set(self.entries(self.get_xml(self.acquisition_path())[0]))
|
|
self.assertNotIn("Already Read Post", titles)
|
|
|
|
def test_read_section_contains_read_articles(self):
|
|
path = self.acquisition_path(section="read")
|
|
titles = set(self.entries(self.get_xml(path)[0]))
|
|
self.assertIn("Already Read Post", titles)
|
|
|
|
def test_entry_offers_an_epub_acquisition_link(self):
|
|
node, _headers = self.get_xml(self.acquisition_path())
|
|
entry = self.entries(node)["A Tech Post & Its Friends"]
|
|
href = self.follow(entry, "http://opds-spec.org/acquisition/open-access")
|
|
self.assertTrue(href.endswith(".epub"))
|
|
types = {link.attr("type") for link in entry.must_find_all("link")}
|
|
self.assertIn("application/epub+zip", types)
|
|
# The generic relation is offered too, because readers disagree.
|
|
self.assertIn(
|
|
"http://opds-spec.org/acquisition",
|
|
{link.attr("rel") for link in entry.must_find_all("link")},
|
|
)
|
|
|
|
def test_entry_links_back_to_the_original_article(self):
|
|
node, _headers = self.get_xml(self.acquisition_path())
|
|
entry = self.entries(node)["A Tech Post & Its Friends"]
|
|
self.assertTrue(self.follow(entry, "alternate").startswith("https://"))
|
|
|
|
def test_entry_carries_its_feed_as_a_category(self):
|
|
node, _headers = self.get_xml(self.acquisition_path())
|
|
entry = self.entries(node)["A Tech Post & Its Friends"]
|
|
labels = {category.attr("label") for category in entry.must_find_all("category")}
|
|
self.assertIn("Example Tech", labels)
|
|
|
|
def test_articles_are_newest_first(self):
|
|
node, _headers = self.get_xml(self.acquisition_path())
|
|
stamps = [entry.must_find("updated").all_text() for entry in node.must_find_all("entry")]
|
|
self.assertEqual(stamps, sorted(stamps, reverse=True))
|
|
|
|
def test_pagination_link_appears_when_there_is_more(self):
|
|
# The test configuration serves two items per page, and the reading list
|
|
# holds five unread articles.
|
|
node, _headers = self.get_xml("/opds/unread/all")
|
|
rels = {link.attr("rel") for link in node.must_find_all("link")}
|
|
self.assertIn("next", rels)
|
|
self.assertIn("first", rels)
|
|
self.assertNotIn("previous", rels)
|
|
|
|
def test_second_page_is_reachable_and_different(self):
|
|
path = "/opds/unread/all"
|
|
first, _ = self.get_xml(path)
|
|
second, _ = self.get_xml(path + "?page=2")
|
|
first_ids = {entry.must_find("id").all_text() for entry in first.must_find_all("entry")}
|
|
second_ids = {entry.must_find("id").all_text() for entry in second.must_find_all("entry")}
|
|
self.assertTrue(second_ids)
|
|
self.assertFalse(first_ids & second_ids)
|
|
|
|
def test_starred_section_lists_starred_articles(self):
|
|
titles = set(self.entries(self.get_xml("/opds/starred")[0]))
|
|
self.assertIn("Starred Investigation", titles)
|
|
|
|
def test_search_finds_articles_in_the_window(self):
|
|
node, _headers = self.get_xml("/opds/search?q=Tech+Post")
|
|
titles = set(self.entries(node))
|
|
self.assertIn("A Tech Post & Its Friends", titles)
|
|
self.assertNotIn("Markets Dip Slightly", titles)
|
|
|
|
def test_empty_search_returns_an_empty_feed(self):
|
|
# A search with no term is a valid, empty acquisition feed rather than an
|
|
# error, so a reader that sends one sees an empty list.
|
|
node, _headers = self.get_xml("/opds/search?q=")
|
|
self.assertEqual(node.find_all("entry"), [])
|
|
|
|
def test_bad_page_number_falls_back_to_the_first_page(self):
|
|
node, _headers = self.get_xml(self.acquisition_path() + "?page=nonsense")
|
|
self.assertTrue(node.must_find_all("entry"))
|
|
|
|
|
|
class DownloadTests(ServerTestCase):
|
|
"""The claim under test: a completed download is what marks an article read."""
|
|
|
|
def test_download_returns_an_epub(self):
|
|
status, headers, body = self.request(self.download_path())
|
|
self.assertEqual(status, 200)
|
|
self.assertEqual(headers["Content-Type"], "application/epub+zip")
|
|
disposition = headers["Content-Disposition"]
|
|
self.assertTrue(disposition.startswith("attachment;"))
|
|
# Both spellings are sent: a plain name every reader understands, and an
|
|
# RFC 5987 one so a non-ASCII title survives.
|
|
self.assertIn('filename="a-tech-post-its-friends.epub"', disposition)
|
|
self.assertIn("filename*=UTF-8''", disposition)
|
|
|
|
def test_downloaded_file_is_a_valid_epub(self):
|
|
_status, _headers, body = self.request(self.download_path())
|
|
archive = zipfile.ZipFile(BytesIO(body))
|
|
self.addCleanup(archive.close)
|
|
self.assertEqual(archive.namelist()[0], "mimetype")
|
|
self.assertEqual(archive.read("mimetype"), b"application/epub+zip")
|
|
self.assertEqual(archive.getinfo("mimetype").compress_type, zipfile.ZIP_STORED)
|
|
opf = parse_xml(archive.read(OPF_PATH))
|
|
self.assertEqual(opf.must_find("title").all_text(), "A Tech Post & Its Friends")
|
|
# The body went through the sanitiser on the way in.
|
|
article = archive.read(ARTICLE_PATH).decode("utf-8")
|
|
self.assertNotIn("alert(", article)
|
|
self.assertIn("Entities: &", article)
|
|
|
|
def test_download_marks_the_article_read_upstream(self):
|
|
self.request(self.download_path())
|
|
self.assertEqual(self.wait_for_mark_read({item_id(1)}), {item_id(1)})
|
|
edits = self.stub.find_requests("/reader/api/0/edit-tag")
|
|
self.assertEqual(len(edits), 1)
|
|
self.assertIn("i=tag%3Agoogle.com", edits[0]["body"])
|
|
|
|
def test_downloads_mark_only_their_own_article(self):
|
|
self.request(self.download_path())
|
|
self.assertEqual(self.wait_for_mark_read({item_id(1)}), {item_id(1)})
|
|
|
|
def test_head_does_not_mark_read(self):
|
|
# A reader probing the URL, or a CDN, must not consume the article.
|
|
status, headers, body = self.request(self.download_path(), method="HEAD")
|
|
self.assertEqual(status, 200)
|
|
self.assertEqual(headers["Content-Type"], "application/epub+zip")
|
|
self.assertEqual(body, b"")
|
|
# Deterministic rather than a race: a HEAD never reaches the mark-read.
|
|
self.assertEqual(self.stub.read - self.baseline_read, set())
|
|
self.assertEqual(self.stub.find_requests("/reader/api/0/edit-tag"), [])
|
|
|
|
def test_missing_article_is_404(self):
|
|
stream = base64.urlsafe_b64encode(TECH_FEED.encode()).decode().rstrip("=")
|
|
absent = (
|
|
base64.urlsafe_b64encode(b"tag:google.com,2005:reader/item/nope").decode().rstrip("=")
|
|
)
|
|
status, _headers, _body = self.request(f"/opds/d/{stream}/{absent}/nope.epub")
|
|
self.assertEqual(status, 404)
|
|
|
|
def test_article_id_is_encoded_in_the_url_and_survives(self):
|
|
# FreshRSS ids contain ':' and '/', so the URL must carry them encoded.
|
|
path = self.download_path()
|
|
self.assertNotIn("tag:google.com", path)
|
|
self.assertEqual(path.count("/"), 5)
|
|
|
|
def test_marked_read_article_leaves_the_unread_queue(self):
|
|
path = self.download_path()
|
|
self.request(path)
|
|
self.wait_for_mark_read({item_id(1)})
|
|
# The stream cache is invalidated by the mark-read, so the next browse
|
|
# reflects it without waiting for a TTL.
|
|
titles = set(self.entries(self.get_xml(self.acquisition_path())[0]))
|
|
self.assertNotIn("A Tech Post & Its Friends", titles)
|
|
|
|
def test_marked_read_article_appears_in_the_read_section(self):
|
|
self.request(self.download_path())
|
|
self.wait_for_mark_read({item_id(1)})
|
|
path = self.acquisition_path(section="read")
|
|
titles = set(self.entries(self.get_xml(path)[0]))
|
|
self.assertIn("A Tech Post & Its Friends", titles)
|
|
|
|
def test_mark_read_can_be_disabled(self):
|
|
self.application.config.freshrss.mark_read = False
|
|
self.request(self.download_path())
|
|
self.assertEqual(self.stub.read - self.baseline_read, set())
|
|
self.assertEqual(self.stub.find_requests("/reader/api/0/edit-tag"), [])
|
|
|
|
def test_advertised_unread_count_refreshes_after_a_download(self):
|
|
"""The count must not lag the queue it describes.
|
|
|
|
Unread counts come from the cached account snapshot, so a mark-read has to
|
|
drop that cache too -- otherwise a reader downloads an article and is still
|
|
told the old total, with one fewer entry underneath it.
|
|
"""
|
|
|
|
def advertised_unread() -> int:
|
|
node, _ = self.get_xml("/opds/unread")
|
|
for entry in node.must_find_all("entry"):
|
|
if entry.must_find("title").all_text() == "All feeds":
|
|
return int(entry.must_find("content").all_text().split()[0])
|
|
raise AssertionError("no 'All feeds' entry in the unread catalog")
|
|
|
|
before = advertised_unread()
|
|
self.request(self.download_path())
|
|
self.wait_for_mark_read({item_id(1)})
|
|
self.assertEqual(advertised_unread(), before - 1)
|
|
|
|
def test_second_download_is_still_served_after_the_queue_moved_on(self):
|
|
path = self.download_path()
|
|
self.request(path)
|
|
status, _headers, body = self.request(path)
|
|
self.assertEqual(status, 200)
|
|
self.assertTrue(body.startswith(b"PK"))
|
|
|
|
|
|
class UpstreamFailureTests(ServerTestCase):
|
|
def test_upstream_outage_is_a_bad_gateway(self):
|
|
self.stub.fail_next(503, count=10, path="/subscription/list")
|
|
status, _headers, _body = self.request("/opds")
|
|
self.assertEqual(status, 502)
|
|
|
|
def test_catalog_recovers_once_upstream_returns(self):
|
|
# Exactly one failure, so the next attempt succeeds.
|
|
self.stub.fail_next(503, path="/subscription/list")
|
|
self.assertEqual(self.request("/opds")[0], 502)
|
|
self.application.invalidate()
|
|
self.assertEqual(self.request("/opds")[0], 200)
|
|
|
|
def test_unread_counts_missing_is_not_fatal(self):
|
|
# The feature is optional; the catalog must still browse without it.
|
|
self.stub.supports_unread_counts = False
|
|
self.application.invalidate()
|
|
status, _headers, body = self.request("/opds/unread")
|
|
self.assertEqual(status, 200)
|
|
node = parse_xml(body)
|
|
titles = {entry.must_find("title").all_text() for entry in node.must_find_all("entry")}
|
|
self.assertIn("Tech", titles)
|
|
|
|
def test_unknown_host_is_refused_when_an_allowlist_is_set(self):
|
|
self.application.config.server.allowed_hosts = ["catalog.example.com"]
|
|
status, _headers, _body = self.request("/opds", auth=False)
|
|
self.assertEqual(status, 500)
|
|
|
|
def test_public_base_url_controls_the_links(self):
|
|
self.application.config.server.public_base_url = "https://catalog.example.com/books"
|
|
node, _headers = self.get_xml("/opds")
|
|
hrefs = {link.must_attr("href") for link in node.must_find_all("link")}
|
|
self.assertTrue(
|
|
any(href.startswith("https://catalog.example.com/books/opds") for href in hrefs)
|
|
)
|
|
|
|
|
|
class SerializationTests(ServerTestCase):
|
|
"""Responses must be correct XML even when titles contain markup."""
|
|
|
|
def test_titles_with_markup_are_escaped(self):
|
|
self.stub.subscriptions[0]["title"] = 'Feed & <Friends> "quoted"'
|
|
self.application.invalidate()
|
|
category = urllib.parse.urlsplit(
|
|
self.follow(self.entries(self.get_xml("/opds/unread")[0])["Tech"], "subsection")
|
|
).path
|
|
node, _headers = self.get_xml(category)
|
|
titles = {entry.must_find("title").all_text() for entry in node.must_find_all("entry")}
|
|
self.assertIn('Feed & <Friends> "quoted"', titles)
|
|
|
|
def test_feed_ids_are_stable_across_requests(self):
|
|
first, _ = self.get_xml("/opds/unread")
|
|
second, _ = self.get_xml("/opds/unread")
|
|
self.assertEqual(first.must_find("id").all_text(), second.must_find("id").all_text())
|
|
|
|
def test_entry_ids_are_unique_within_a_feed(self):
|
|
node, _headers = self.get_xml(self.acquisition_path())
|
|
ids = [entry.must_find("id").all_text() for entry in node.must_find_all("entry")]
|
|
self.assertEqual(len(ids), len(set(ids)))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|