Allowing users to delete suggestions

Sources/History/HistoryCoordinator.swift

@@ -44,6 +44,7 @@ public protocol HistoryCoordinating: AnyObject {
     func burnDomains(_ baseDomains: Set<String>, tld: TLD, completion: @escaping (Set<URL>) -> Void)
     func burnVisits(_ visits: [Visit], completion: @escaping () -> Void)
 
+    func removeUrlEntry(_ url: URL, completion: ((Error?) -> Void)?)
 }
 
 /// Coordinates access to History. Uses its own queue with high qos for all operations.
@@ -191,6 +192,20 @@ final public class HistoryCoordinator: HistoryCoordinating {
         }
     }
 
+    public enum EntryRemovalError: Error {
+        case notAvailable
+    }
+
+    public func removeUrlEntry(_ url: URL, completion: ((Error?) -> Void)? = nil) {
+        guard let historyDictionary = historyDictionary else { return }
+        guard let entry = historyDictionary[url] else {
+            completion?(EntryRemovalError.notAvailable)
+            return
+        }
+
+        removeEntries([entry], completionHandler: completion)
+    }
+
     var cleaningDate: Date { .monthAgo }
 
     @objc private func cleanOld() {

Sources/Suggestions/Suggestion.swift

@@ -28,7 +28,7 @@ public enum Suggestion: Equatable {
     case openTab(title: String, url: URL)
     case unknown(value: String)
 
-    var url: URL? {
+    public var url: URL? {
         switch self {
         case .website(url: let url),
              .historyEntry(title: _, url: let url, allowedInTopHits: _),
@@ -67,20 +67,26 @@ public enum Suggestion: Equatable {
         }
     }
 
-    var isOpenTab: Bool {
+    public var isOpenTab: Bool {
         if case .openTab = self {
             return true
         }
         return false
     }
 
-    var isBookmark: Bool {
+    public var isBookmark: Bool {
         if case .bookmark = self {
             return true
         }
         return false
     }
 
+    public var isHistoryEntry: Bool {
+        if case .historyEntry = self {
+            return true
+        }
+        return false
+    }
 }
 
 extension Suggestion {

Sources/Suggestions/SuggestionResult.swift

@@ -24,9 +24,9 @@ public struct SuggestionResult: Equatable {
         SuggestionResult(topHits: [], duckduckgoSuggestions: [], localSuggestions: [])
     }
 
-    private(set) public var topHits: [Suggestion]
-    private(set) public var duckduckgoSuggestions: [Suggestion]
-    private(set) public var localSuggestions: [Suggestion]
+    public let topHits: [Suggestion]
+    public let duckduckgoSuggestions: [Suggestion]
+    public let localSuggestions: [Suggestion]
 
     public init(topHits: [Suggestion],
                 duckduckgoSuggestions: [Suggestion],

Tests/HistoryTests/HistoryCoordinatorTests.swift

@@ -316,6 +316,43 @@ class HistoryCoordinatorTests: XCTestCase {
         return bookmarksDatabase
     }
 
+    func testWhenRemoveUrlEntryCalledWithExistingUrl_ThenEntryIsRemovedAndNoError() {
+        let (historyStoringMock, historyCoordinator) = HistoryCoordinator.aHistoryCoordinator
+
+        let url = URL(string: "https://duckduckgo.com")!
+        historyCoordinator.addVisit(of: url)
+
+        XCTAssertTrue(historyCoordinator.history!.contains(where: { $0.url == url }))
+
+        let removalExpectation = expectation(description: "Entry removed without error")
+        historyCoordinator.removeUrlEntry(url) { error in
+            XCTAssertNil(error, "Expected no error when removing an existing URL entry")
+            removalExpectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 1.0)
+
+        XCTAssertFalse(historyCoordinator.history!.contains(where: { $0.url == url }))
+        XCTAssertTrue(historyStoringMock.removeEntriesCalled, "Expected removeEntries to be called")
+        XCTAssertEqual(historyStoringMock.removeEntriesArray.count, 1)
+        XCTAssertEqual(historyStoringMock.removeEntriesArray.first?.url, url)
+    }
+
+    func testWhenRemoveUrlEntryCalledWithNonExistingUrl_ThenEntryRemovalFailsWithNotAvailableError() {
+        let (_, historyCoordinator) = HistoryCoordinator.aHistoryCoordinator
+
+        let nonExistentUrl = URL(string: "https://nonexistent.com")!
+
+        let removalExpectation = expectation(description: "Entry removal fails with notAvailable error")
+        historyCoordinator.removeUrlEntry(nonExistentUrl) { error in
+            XCTAssertNotNil(error, "Expected an error when removing a non-existent URL entry")
+            XCTAssertEqual(error as? HistoryCoordinator.EntryRemovalError, .notAvailable, "Expected notAvailable error")
+            removalExpectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 1.0)
+    }
+
 }
 
 fileprivate extension HistoryCoordinator {