Send the filter names ipx actually understands (#6)

The Pinned tab was not filtering. It sent filter=pinned, and Filter::parse
in db.rs knows unread, downloaded, flagged and in_progress and falls
through to All for anything else -- so the tab returned every item and
looked like it had worked. The column is still named flagged, for what it
was before the interface called it pinned, and the page had this right all
along.

Currently Listening was worse in kind. ipx has filter=in_progress for
exactly it: started past the first few seconds, short of the 90% the UI
calls finished, measured against the length this person's player reported
where there is one. The client asked for everything and trimmed the fifty
rows it happened to receive, so the view showed whichever started episodes
were near the top of the library, left out the rest, and counted wrong.

Both came of writing the filter names from the interface's words instead of
reading what the server parses.

The tests now assert what each filter means rather than how many rows it
returns -- every unread row unread, every downloaded row with a file, every
pinned row pinned, every in-progress row started -- because the failure
here was a full page of entirely plausible rows, which no count would have
caught. Pinned also has to match fewer than everything, which is the shape
the bug took.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

ios/Tests/APITests.swift

@@ -84,6 +84,37 @@ final class APITests: XCTestCase {
         XCTAssertEqual(asc.entries.map(\.guid), desc.entries.map(\.guid).reversed())
     }
 
+    /// Every filter, checked against what it means rather than against a count. The bug this
+    /// replaces was a filter name the server did not know: it fell through to All and returned
+    /// a full page of plausible rows, which no count-based assertion would have noticed.
+    func testEachFilterReturnsOnlyWhatItMeans() async throws {
+        let all = try await api.entries(filter: .all, limit: 200)
+
+        let unread = try await api.entries(filter: .unread, limit: 200)
+        XCTAssertTrue(unread.entries.allSatisfy { !$0.read }, "unread returned a read item")
+
+        let downloaded = try await api.entries(filter: .downloaded, limit: 200)
+        XCTAssertTrue(downloaded.entries.allSatisfy { $0.enclosures.contains(where: \.isDownloaded) },
+                      "downloaded returned an item with no file")
+
+        let pinned = try await api.entries(filter: .pinned, limit: 200)
+        XCTAssertTrue(pinned.entries.allSatisfy(\.flagged), "pinned returned an unpinned item")
+        XCTAssertLessThan(pinned.total, all.total,
+                          "pinned matched everything, which is what a filter name the server "
+                          + "does not understand looks like")
+
+        let started = try await api.entries(filter: .inProgress, limit: 200)
+        XCTAssertTrue(started.entries.allSatisfy { $0.position > 0 },
+                      "in_progress returned an item nobody has started")
+    }
+
+    /// The raw values are the wire format, and getting one wrong fails silently.
+    func testFilterNamesAreTheOnesTheServerKnows() {
+        XCTAssertEqual(IPX.Filter.pinned.rawValue, "flagged")
+        XCTAssertEqual(IPX.Filter.inProgress.rawValue, "in_progress")
+        XCTAssertEqual(IPX.Filter.tabs.map(\.rawValue), ["all", "unread", "downloaded", "flagged"])
+    }
+
     func testSearchMatchesTitles() async throws {
         let hit = try await api.entries(feed: "test-show", search: "Second")
         XCTAssertEqual(hit.entries.count, 1)