From 1f8b7a23529462c3c332753d33810b5c9f692bbc Mon Sep 17 00:00:00 2001
From: Christian Cleberg <hello@cleberg.net>
Date: Sun, 22 Mar 2026 20:42:45 -0500
Subject: feat: add search to builds, trackers, tickets, pastes, mailing lists,
 and inbox

---
 HutchTests/BuildListViewModelTests.swift   | 55 ++++++++++++++++++++++++++++
 HutchTests/InboxViewModelTests.swift       | 52 +++++++++++++++++++++++++++
 HutchTests/TrackerListViewModelTests.swift | 58 ++++++++++++++++++++++++++++++
 3 files changed, 165 insertions(+)
 create mode 100644 HutchTests/BuildListViewModelTests.swift

(limited to 'HutchTests')

diff --git a/HutchTests/BuildListViewModelTests.swift b/HutchTests/BuildListViewModelTests.swift
new file mode 100644
index 0000000..a5c2483
--- /dev/null
+++ b/HutchTests/BuildListViewModelTests.swift
@@ -0,0 +1,55 @@
+import Foundation
+import Testing
+@testable import Hutch
+
+struct BuildListViewModelTests {
+
+    @Test
+    func filteredJobsReturnsAllWhenSearchTextIsEmpty() {
+        let jobs = [makeJob(id: 1, tags: ["ci"]), makeJob(id: 2, tags: [])]
+        let filtered = filterJobs(jobs, query: "")
+
+        #expect(filtered.count == 2)
+    }
+
+    @Test
+    func filteredJobsMatchesByTag() {
+        let jobs = [makeJob(id: 1, tags: ["ci", "deploy"]), makeJob(id: 2, tags: ["lint"])]
+        let filtered = filterJobs(jobs, query: "deploy")
+
+        #expect(filtered.map(\.id) == [1])
+    }
+
+    @Test
+    func filteredJobsMatchesByJobId() {
+        let jobs = [makeJob(id: 42, tags: []), makeJob(id: 99, tags: [])]
+        let filtered = filterJobs(jobs, query: "42")
+
+        #expect(filtered.map(\.id) == [42])
+    }
+
+    private func filterJobs(_ jobs: [JobSummary], query: String) -> [JobSummary] {
+        let q = query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard !q.isEmpty else { return jobs }
+        return jobs.filter {
+            String($0.id).contains(q) ||
+            $0.tags.contains { $0.lowercased().contains(q) } ||
+            ($0.note?.lowercased().contains(q) == true) ||
+            ($0.image?.lowercased().contains(q) == true)
+        }
+    }
+
+    private func makeJob(id: Int, tags: [String]) -> JobSummary {
+        JobSummary(
+            id: id,
+            created: Date(),
+            updated: Date(),
+            status: .success,
+            note: nil,
+            tags: tags,
+            visibility: nil,
+            image: nil,
+            tasks: []
+        )
+    }
+}
diff --git a/HutchTests/InboxViewModelTests.swift b/HutchTests/InboxViewModelTests.swift
index b202d03..597bbc2 100644
--- a/HutchTests/InboxViewModelTests.swift
+++ b/HutchTests/InboxViewModelTests.swift
@@ -113,6 +113,58 @@ struct InboxViewModelTests {
         #expect(first.id != second.id)
     }
 
+    @Test
+    func mailingListThreadFilterMatchesSubjectAndSender() {
+        let baseList = InboxMailingListReference(
+            id: 1,
+            rid: "list",
+            name: "hutch-devel",
+            owner: Entity(canonicalName: "~owner")
+        )
+        let threads = [
+            InboxThreadSummary(
+                rootEmailID: 10,
+                rootMessageID: "message-1",
+                threadRootEmailIDs: [10],
+                threadRootMessageIDs: ["message-1"],
+                listID: baseList.id,
+                listRID: baseList.rid,
+                listName: baseList.name,
+                listOwner: baseList.owner,
+                subject: "Re: [PATCH] add search",
+                latestSender: Entity(canonicalName: "~alice"),
+                lastActivityAt: Date(timeIntervalSince1970: 100),
+                messageCount: 1,
+                repo: "hutch",
+                containsPatch: true,
+                isUnread: true
+            ),
+            InboxThreadSummary(
+                rootEmailID: 11,
+                rootMessageID: "message-2",
+                threadRootEmailIDs: [11],
+                threadRootMessageIDs: ["message-2"],
+                listID: baseList.id,
+                listRID: baseList.rid,
+                listName: baseList.name,
+                listOwner: baseList.owner,
+                subject: "Release planning",
+                latestSender: Entity(canonicalName: "~bob"),
+                lastActivityAt: Date(timeIntervalSince1970: 200),
+                messageCount: 2,
+                repo: "hutch",
+                containsPatch: false,
+                isUnread: true
+            )
+        ]
+
+        let subjectMatches = MailingListDetailViewModel.filterThreads(threads, matching: "search")
+        let senderMatches = MailingListDetailViewModel.filterThreads(threads, matching: "~bob")
+
+        #expect(subjectMatches.map(\.rootEmailID) == [10])
+        #expect(senderMatches.map(\.rootEmailID) == [11])
+    }
+
     @Test
     func segmentsPatchBodyAndTreatsSignatureAsPlainText() {
         let body = """
diff --git a/HutchTests/TrackerListViewModelTests.swift b/HutchTests/TrackerListViewModelTests.swift
index 1caedea..7e927af 100644
--- a/HutchTests/TrackerListViewModelTests.swift
+++ b/HutchTests/TrackerListViewModelTests.swift
@@ -13,4 +13,62 @@ struct TrackerListViewModelTests {
 
         #expect(error.localizedDescription == "GraphQL error: A tracker named bugs already exists")
     }
+
+    @Test
+    func filteredTrackersReturnsAllWhenSearchTextIsEmpty() {
+        let trackers = [
+            makeTracker(id: 1, name: "bugs", description: "Bug tracker", owner: "~owner"),
+            makeTracker(id: 2, name: "ideas", description: nil, owner: "~team")
+        ]
+
+        let filtered = filterTrackers(trackers, query: "")
+
+        #expect(filtered.count == 2)
+    }
+
+    @Test
+    func filteredTrackersMatchesDescription() {
+        let trackers = [
+            makeTracker(id: 1, name: "bugs", description: "Production incidents", owner: "~owner"),
+            makeTracker(id: 2, name: "ideas", description: "Feature requests", owner: "~team")
+        ]
+
+        let filtered = filterTrackers(trackers, query: "incident")
+
+        #expect(filtered.map(\.id) == [1])
+    }
+
+    @Test
+    func filteredTrackersMatchesOwner() {
+        let trackers = [
+            makeTracker(id: 1, name: "bugs", description: nil, owner: "~owner"),
+            makeTracker(id: 2, name: "ideas", description: nil, owner: "~team")
+        ]
+
+        let filtered = filterTrackers(trackers, query: "~team")
+
+        #expect(filtered.map(\.id) == [2])
+    }
+
+    private func filterTrackers(_ trackers: [TrackerSummary], query: String) -> [TrackerSummary] {
+        let q = query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard !q.isEmpty else { return trackers }
+        return trackers.filter {
+            $0.name.lowercased().contains(q) ||
+            ($0.description?.lowercased().contains(q) == true) ||
+            $0.owner.canonicalName.lowercased().contains(q)
+        }
+    }
+
+    private func makeTracker(id: Int, name: String, description: String?, owner: String) -> TrackerSummary {
+        TrackerSummary(
+            id: id,
+            rid: "rid-\(id)",
+            name: name,
+            description: description,
+            visibility: .public,
+            updated: Date(),
+            owner: Entity(canonicalName: owner)
+        )
+    }
 }
-- 
cgit v1.2.3