* Centralize library management logic and introduce support for plain text and HTML formats

* Centralize library management logic and introduce support for plain text and HTML formats

* Expand unit test coverage for library state management, UI models, and MainViewModel features.

* Add comprehensive unit tests for PDF reader core logic, preferences, and data persistence

* Add unit tests for EPUB parsing, content loading, search functionality, and reader JavaScript bridges.

* Add unit tests for OPDS parsing and Smart Collection engine, and integrate Kover plugin

* Add comprehensive unit tests

* Centralize library snapshot serialization in the `shared` module and improve filtering and sorting logic.

* Implement text selection, highlighting, and reading state persistence for PDF and EPUB engines in desktop version

* Folder import support for desktop app

* Introduce Smart Shelves with rule-based filtering in desktop version

* Implement shared EPUB annotation serialization and highlight rendering

* Centralize file type capabilities and platform-specific support logic

* Refactor reader state management to use a central reducer

* Implement customizable reader toolbar and advanced formatting settings in shared

* Implement locator-based navigation and customizable highlight palette for desktop app

* Enhance reader customization and expand search functionality in desktop app

* Redesign reader settings and tools into a tabbed control panel in desktop app

* Enhance reader navigation and highlight precision in desktop app

* Implement bidirectional position synchronization and dynamic highlights in the desktop reader

* Implement shared state management and enhanced search for the PDF reader in desktop app

* Add vertical scroll support to the desktop PDF reader

* Implement ink, text, and eraser annotation support in desktop PDF viewer

* Implement PDF bookmarks, Table of Contents, and annotation editing in desktop app

* Implement link handling and navigation for PDF and EPUB readers in desktop app

* Implement PDF jump history for navigation in desktop app

* Enhance PDF ink rendering and annotation capabilities in desktop app

* Implement advanced PDF text annotations with inline editing and rich styling in desktop app

* Add move handle and movement logic for PDF text annotations in desktop app

* Implement local folder synchronization and metadata sidecar support in desktop app

* Implement book metadata extraction and drag-and-drop import for Desktop

* Implement dynamic and custom app theme management for desktop

* Introduce canonical PDF annotation codec and support for multi-segment highlights

* Implement rich text editing and pagination support for the PDF reader in desktop app

* Improve PDF rich text pagination, synchronization, and observability in desktop

* Hide trailing structural page breaks in rich text editor

* Implement a unified JVM book loader and expand supported formats on Desktop

* Add comic archive support for Desktop and enhance MOBI parsing

* Implement shared OPDS catalog support and UI for Android and Desktop

* Improve native WebView lifecycle and surface transition management on Desktop

* Enable Compose Swing interop blending and simplify Desktop WebView management

* Integrate BYOK AI features and Cloud TTS for desktop

* Enhance Desktop TTS with streaming audio and improved secure storage for AI key

* Implement scoped Cloud TTS with synchronized highlighting for EPUB and PDF in desktop app

* Implement custom font management and utility screens in desktop app

* Implement PDFium-based PDF annotation export

* Remove PdfBox dependency and standardize PDF export via Pdfium

* Implement local audio caching and playback controls for Gemini Cloud TTS in desktop app

* Implement reader themes and custom texture support in desktop app

* Redesign non-reader UI with responsive navigation and enhanced library management in desktop app

* Introduce ReaderWorkspaceShell to unify EPUB and PDF reader layouts in desktop app

* Exclude manual-only files from automated sync and import

* Implement customizable Text-to-Speech (TTS) word replacements

* Optimize reader performance with persistent layout caching and decoupled theme rendering

* Improve position restoration during reader reconfiguration in epub pagination

* Use independent thickness for eraser tool and stylus override
This commit is contained in:
Aryan 2026-05-10 10:07:37 +05:30 committed by GitHub
parent 88c7fa7b5c
commit 8366d76dcd
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
214 changed files with 53372 additions and 4702 deletions

View file

@ -0,0 +1,208 @@
package com.aryan.reader.opds
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
@RunWith(RobolectricTestRunner::class)
class OpdsParserTest {
@Test
fun `parse OPDS 2 feed resolves links facets navigation publications and metadata`() {
val feed = OpdsParser().parse(
bodyString = """
{
"metadata": {"title": "Catalog"},
"links": [
{"rel": "next", "href": "page/2"},
{"rel": ["search"], "href": "search{?query}"}
],
"facets": [
{
"metadata": {"title": "Format"},
"links": [
{"title": "EPUB", "href": "?format=epub", "properties": {"active": true}}
]
}
],
"navigation": [
{"title": "Authors", "href": "../authors", "description": "Browse authors"}
],
"publications": [
{
"metadata": {
"identifier": "pub-1",
"title": "Example Book",
"description": "Long summary",
"author": [{"name": "Ada Writer", "links": [{"href": "/authors/ada"}]}],
"language": "en",
"publisher": "Example Press",
"published": "2026-01-02",
"subject": [{"name": "Fiction"}],
"belongsTo": {"series": {"name": "Series", "position": 2}}
},
"images": [
{"href": "images/thumb.jpg"},
{"rel": "cover", "href": "images/cover.jpg"}
],
"links": [
{
"rel": "http://opds-spec.org/acquisition",
"href": "downloads/book.epub",
"type": "application/epub+zip"
},
{
"rel": ["http://vaemendis.net/opds-pse/stream"],
"href": "stream/{page}",
"properties": {"numberOfItems": 12}
}
]
}
]
}
""".trimIndent(),
baseUrl = "https://example.org/opds/catalog/index.json"
)
assertEquals("Catalog", feed.title)
assertEquals("https://example.org/opds/catalog/page/2", feed.nextUrl)
assertEquals("https://example.org/opds/catalog/search{?query}", feed.searchUrl)
assertEquals(OpdsFacet("EPUB", "Format", "https://example.org/opds/catalog/?format=epub", true), feed.facets.single())
val navigation = feed.entries.first { it.isNavigation }
assertEquals("Authors", navigation.title)
assertEquals("https://example.org/opds/authors", navigation.navigationUrl)
val publication = feed.entries.first { it.isAcquisition }
assertEquals("pub-1", publication.id)
assertEquals("Example Book", publication.title)
assertEquals("Ada Writer", publication.author)
assertEquals("https://example.org/authors/ada", publication.authors.single().url)
assertEquals("Long summary", publication.summary)
assertEquals("https://example.org/opds/catalog/images/cover.jpg", publication.coverUrl)
assertEquals("Example Press", publication.publisher)
assertEquals("2026-01-02", publication.published)
assertEquals("en", publication.language)
assertEquals("Series", publication.series)
assertEquals("2", publication.seriesIndex)
assertEquals(listOf("Fiction"), publication.categories)
assertEquals("https://example.org/opds/catalog/downloads/book.epub", publication.bestAcquisition?.url)
assertEquals("EPUB", publication.bestAcquisition?.formatName)
assertEquals(12, publication.pseCount)
assertEquals("https://example.org/opds/catalog/stream/{page}", publication.pseUrlTemplate)
assertTrue(publication.isStreamable)
}
@Test
fun `parse OPDS 1 feed extracts catalog links entry metadata acquisitions and stream info`() {
val feed = OpdsParser().parse(
bodyString = """
<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"
xmlns:opds="http://opds-spec.org/2010/catalog"
xmlns:pse="http://vaemendis.net/opds-pse/ns">
<title>XML Catalog</title>
<link rel="next" href="next.xml" />
<link rel="search" href="/search.xml" />
<link rel="facet" title="English" href="?lang=en" opds:facetGroup="Language" opds:activeFacet="true" />
<entry>
<id>xml-1</id>
<title>XML Book</title>
<summary>Summary text</summary>
<author>
<name>XML Author</name>
<uri>/people/xml-author</uri>
</author>
<publisher>XML Press</publisher>
<language>en</language>
<published>2025-12-31</published>
<category term="fiction" label="Fiction" />
<meta property="calibre:series">XML Series</meta>
<meta property="calibre:series_index">3</meta>
<link rel="http://opds-spec.org/image/thumbnail" href="thumb.jpg" />
<link rel="http://opds-spec.org/image" href="cover.jpg" />
<link rel="http://opds-spec.org/acquisition" type="application/pdf" href="book.pdf" />
<link rel="http://vaemendis.net/opds-pse/stream" href="stream/{page}" pse:count="8" />
</entry>
</feed>
""".trimIndent(),
baseUrl = "https://example.org/root/feed.xml"
)
assertEquals("XML Catalog", feed.title)
assertEquals("https://example.org/root/next.xml", feed.nextUrl)
assertEquals("https://example.org/search.xml", feed.searchUrl)
assertEquals(OpdsFacet("English", "Language", "https://example.org/root/?lang=en", true), feed.facets.single())
val entry = feed.entries.single()
assertEquals("xml-1", entry.id)
assertEquals("XML Book", entry.title)
assertEquals("Summary text", entry.summary)
assertEquals(OpdsAuthor("XML Author", "https://example.org/people/xml-author"), entry.authors.single())
assertEquals("https://example.org/root/thumb.jpg", entry.coverUrl)
assertEquals("XML Press", entry.publisher)
assertEquals("2025-12-31", entry.published)
assertEquals("en", entry.language)
assertEquals("XML Series", entry.series)
assertEquals("3", entry.seriesIndex)
assertEquals(listOf("Fiction"), entry.categories)
assertEquals(OpdsAcquisition("https://example.org/root/book.pdf", "application/pdf"), entry.acquisitions.single())
assertEquals(8, entry.pseCount)
assertEquals("https://example.org/root/stream/{page}", entry.pseUrlTemplate)
}
@Test
fun `parse OPDS 2 groups and fallback metadata produce navigation entries`() {
val feed = OpdsParser().parse(
bodyString = """
{
"groups": [
{
"metadata": {"title": "Group Title"},
"links": [{"href": "group-feed"}],
"navigation": [{"title": "Nested Nav", "href": "nested"}],
"publications": [{"links": [], "metadata": {"title": "No Identifier"}}]
}
]
}
""".trimIndent(),
baseUrl = "https://example.org/catalog/"
)
assertEquals("OPDS 2.0 Feed", feed.title)
assertEquals("Nested Nav", feed.entries[0].title)
assertEquals("https://example.org/catalog/nested", feed.entries[0].navigationUrl)
assertEquals("Group Title", feed.entries[2].title)
assertEquals("https://example.org/catalog/group-feed", feed.entries[2].navigationUrl)
assertEquals("No Identifier", feed.entries[1].title)
assertFalse(feed.entries[1].isAcquisition)
assertNull(feed.entries[1].bestAcquisition)
}
@Test
fun `acquisition format names and priority prefer richer reader formats`() {
val acquisitions = listOf(
OpdsAcquisition("txt", "text/plain"),
OpdsAcquisition("pdf", "application/pdf"),
OpdsAcquisition("epub", "application/epub+zip"),
OpdsAcquisition("unknown", "application/octet-stream")
)
val entry = OpdsEntry(
id = "id",
title = "Book",
summary = null,
coverUrl = null,
acquisitions = acquisitions,
navigationUrl = null
)
assertEquals("EPUB", acquisitions[2].formatName)
assertEquals("TXT", acquisitions[0].formatName)
assertEquals("OCTET-STREAM", acquisitions[3].formatName)
assertEquals(acquisitions[2], entry.bestAcquisition)
}
}