fenilsonani / menu-browser / Tests/ URLRuleManagerTests.swift

import Foundation

enum URLRuleManagerTests {
    static func run() -> Suite {
        let suite = Suite("URLRuleManager")

        withTemporaryDefaults("com.fenilsonani.MenuBrowser.tests.rules") { defaults in
            let manager = URLRuleManager(defaults: defaults)
            suite.expect(manager.rules.isEmpty, "starts with an empty rule set")

            manager.addRule(pattern: "HTTPS://GitHub.com/work/", browserBundleID: "browser.work")
            manager.addRule(pattern: "github.com", browserBundleID: "browser.default")
            manager.addRule(pattern: "docs.example.com", browserBundleID: "browser.docs")

            guard let workRule = rule(matching: "github.com/work", in: manager, suite: suite),
                  let githubRule = rule(matching: "github.com", in: manager, suite: suite),
                  let docsRule = rule(matching: "docs.example.com", in: manager, suite: suite)
            else { return }

            let workURL = URL(string: "https://github.com/work/issues/123")!
            suite.expect(manager.matchingRule(for: workURL)?.id == workRule.id, "path rule wins over domain rule")
            suite.expect(manager.hitCount(for: workRule) == 0, "non-recording matches don't bump hit counts")

            suite.expect(
                manager.matchingRule(for: workURL, recordHit: true)?.id == workRule.id,
                "recording match still returns the matching rule"
            )
            suite.expect(manager.hitCount(for: workRule) == 1, "recorded match increments hit count")

            let subdomainURL = URL(string: "https://support.github.com/login")!
            suite.expect(
                manager.matchingBrowser(for: subdomainURL) == "browser.default",
                "domain rule matches subdomains"
            )
            suite.expect(manager.hitCount(for: githubRule) == 1, "matchingBrowser records hits")

            let docsURL = URL(string: "https://api.docs.example.com/reference")!
            suite.expect(
                manager.matchingRule(for: docsURL)?.id == docsRule.id,
                "domain rules match nested subdomains"
            )

            manager.toggleRule(id: docsRule.id)
            suite.expect(manager.matchingRule(for: docsURL) == nil, "disabled rules don't match")

            manager.deleteRule(id: workRule.id)
            suite.expect(
                manager.matchingRule(for: workURL)?.id == githubRule.id,
                "deleting a specific rule exposes the broader rule"
            )
            suite.expect(manager.hitCount(for: workRule) == 0, "deleting a rule clears its stored hit count")
        }

        return suite
    }

    private static func rule(matching pattern: String, in manager: URLRuleManager, suite: Suite) -> URLRule? {
        guard let found = manager.rules.first(where: { $0.pattern == pattern }) else {
            suite.fail("missing rule \(pattern)")
            return nil
        }
        return found
    }
}