From 92e3d51acba485a7b282e4ea4d4e8e137e9b7913 Mon Sep 17 00:00:00 2001 From: ykisana Date: Wed, 18 Nov 2026 04:21:33 -0600 Subject: [PATCH] feat: let groups override the default unblock duration and key Edit Group has a new Unblocking section with Default Duration and Default Key. Both start on App Default, which follows Settings; any other choice, including None, overrides it for that group. A group's default applies wherever the app default would: its card, widgets and links set to Default Duration, and Shortcuts. Explicit choices and Unblock All are unchanged. Closes #91. --- .../Intents/AppUnblockIntentPerformer.swift | 17 ++- Normal/Models/AppGroup.swift | 36 ++++++ Normal/Models/DefaultOverride.swift | 5 + Normal/Models/Settings+GroupDefaults.swift | 17 +++ Normal/Models/Settings+UnblockDurations.swift | 4 +- Normal/Modifiers/WidgetActionResponder.swift | 2 +- Normal/Resources/Localizable.xcstrings | 8 ++ Normal/Services/UnblockTarget.swift | 7 + .../TimedUnlock/UnblockDurationSheet.swift | 2 +- Normal/Views/Groups/GroupFormSheet.swift | 120 +++++++++++++++++- Normal/Views/Groups/GroupListCardView.swift | 2 +- Normal/Views/Groups/GroupsView.swift | 4 +- .../Models/GroupUnblockDefaultsTests.swift | 85 +++++++++++++ .../Models/SettingsUnblockDurationTests.swift | 10 +- NormalTests/Models/StoreUpgradeTests.swift | 2 + .../AppUnblockIntentPerformerTests.swift | 26 ++++ NormalUITests/BlockingUITests.swift | 38 ++++++ 17 files changed, 365 insertions(+), 20 deletions(-) create mode 100644 Normal/Models/DefaultOverride.swift create mode 100644 Normal/Models/Settings+GroupDefaults.swift create mode 100644 NormalTests/Models/GroupUnblockDefaultsTests.swift diff --git a/Normal/Intents/AppUnblockIntentPerformer.swift b/Normal/Intents/AppUnblockIntentPerformer.swift index 166a05e..fbfa2b7 100644 --- a/Normal/Intents/AppUnblockIntentPerformer.swift +++ b/Normal/Intents/AppUnblockIntentPerformer.swift @@ -40,16 +40,18 @@ final class AppUnblockIntentPerformer: UnblockIntentPerforming { func unblock(_ request: UnblockRequest) async throws -> UnblockOutcome { logger.info("Unblock intent: \(request.groupID == nil ? "all" : "group", privacy: .public)") let settings: Settings + let target: UnblockTarget switch try readiness(for: request) { case let .settled(outcome): return outcome - case let .ready(readySettings, _): + case let .ready(readySettings, readyTarget): settings = readySettings + target = readyTarget } let keys = try Key.scoped(intents.keys(), toGroup: request.groupID) - guard keyType(for: request, keys: keys, settings: settings) == .location, - settings.unblockLength(for: request.duration) != nil + guard keyType(for: request, keys: keys, settings: settings, group: target.group) == .location, + settings.unblockLength(for: request.duration, group: target.group) != nil else { return .continueInApp(.checkKey) } let radiusKind = Key.existingLocationKind(in: keys) ?? .unblock @@ -75,7 +77,7 @@ final class AppUnblockIntentPerformer: UnblockIntentPerforming { case let .settled(outcome): return outcome case let .ready(settings, target): - guard let length = settings.unblockLength(for: request.duration), + guard let length = settings.unblockLength(for: request.duration, group: target.group), let grant = UnblockGrant(target, proof: proof) else { return .continueInApp(.checkKey) } return try start(grant, for: length, settings: settings) @@ -89,7 +91,8 @@ final class AppUnblockIntentPerformer: UnblockIntentPerforming { keyType: keyType( for: request, keys: Key.scoped((try? intents.keys()) ?? [], toGroup: request.groupID), - settings: intents.settings() + settings: intents.settings(), + group: request.groupID.flatMap { try? intents.group(id: $0) } ) )) } @@ -129,10 +132,10 @@ final class AppUnblockIntentPerformer: UnblockIntentPerforming { return .unblocked(name: grant.target.name, length: length) } - private func keyType(for request: UnblockRequest, keys: [Key], settings: Settings?) -> KeyType? { + private func keyType(for request: UnblockRequest, keys: [Key], settings: Settings?, group: AppGroup?) -> KeyType? { KeySelectLogic.shortcutKeyType( requested: request.keyType, - defaultKeyType: settings?.defaultKeyType, + defaultKeyType: settings?.defaultKeyType(for: group), availableKeyTypes: KeyType.selectable(registered: keys.map(\.type)) ) } diff --git a/Normal/Models/AppGroup.swift b/Normal/Models/AppGroup.swift index fa40beb..1edd970 100644 --- a/Normal/Models/AppGroup.swift +++ b/Normal/Models/AppGroup.swift @@ -10,6 +10,10 @@ final class AppGroup: Identifiable { var lastUpdated: Date var sortIndex: Int = 0 var customDomains: [String] = [] + var overridesDefaultDuration: Bool = false + var defaultUnblockSeconds: Int? + var overridesDefaultKey: Bool = false + var defaultKeyType: KeyType? init(id: UUID = UUID(), name: String, selection: FamilyActivitySelection, sortIndex: Int = 0, customDomains: [String] = []) { self.id = id @@ -20,6 +24,38 @@ final class AppGroup: Identifiable { self.customDomains = customDomains } + var durationOverride: DefaultOverride { + get { + guard overridesDefaultDuration else { return .appDefault } + return defaultUnblockSeconds + .flatMap(TimedUnblockDuration.init(validating:)) + .map(DefaultOverride.value) ?? .none + } + set { + overridesDefaultDuration = newValue != .appDefault + if case let .value(duration) = newValue { + defaultUnblockSeconds = duration.seconds + } else { + defaultUnblockSeconds = nil + } + } + } + + var keyOverride: DefaultOverride { + get { + guard overridesDefaultKey else { return .appDefault } + return defaultKeyType.map(DefaultOverride.value) ?? .none + } + set { + overridesDefaultKey = newValue != .appDefault + if case let .value(keyType) = newValue { + defaultKeyType = keyType + } else { + defaultKeyType = nil + } + } + } + func deleteCascading(keys: [Key], from context: ModelContext) { for key in keys where key.groupID == id { context.delete(key) diff --git a/Normal/Models/DefaultOverride.swift b/Normal/Models/DefaultOverride.swift new file mode 100644 index 0000000..2a6c8dc --- /dev/null +++ b/Normal/Models/DefaultOverride.swift @@ -0,0 +1,5 @@ +enum DefaultOverride: Hashable { + case appDefault + case none + case value(Value) +} diff --git a/Normal/Models/Settings+GroupDefaults.swift b/Normal/Models/Settings+GroupDefaults.swift new file mode 100644 index 0000000..b980c17 --- /dev/null +++ b/Normal/Models/Settings+GroupDefaults.swift @@ -0,0 +1,17 @@ +extension Settings { + func defaultDuration(for group: AppGroup?) -> TimedUnblockDuration? { + switch group?.durationOverride ?? .appDefault { + case .appDefault: defaultDuration + case .none: nil + case let .value(duration): unblockDurations.contains(duration) ? duration : nil + } + } + + func defaultKeyType(for group: AppGroup?) -> KeyType? { + switch group?.keyOverride ?? .appDefault { + case .appDefault: defaultKeyType + case .none: nil + case let .value(keyType): keyType + } + } +} diff --git a/Normal/Models/Settings+UnblockDurations.swift b/Normal/Models/Settings+UnblockDurations.swift index 56ed00c..b32a22b 100644 --- a/Normal/Models/Settings+UnblockDurations.swift +++ b/Normal/Models/Settings+UnblockDurations.swift @@ -33,11 +33,11 @@ extension Settings { } } - func unblockLength(for request: UnlockDurationRequest) -> UnblockLength? { + func unblockLength(for request: UnlockDurationRequest, group: AppGroup?) -> UnblockLength? { switch request { case let .fixed(duration): .timed(duration) case .permanent: .permanent - case .useDefault: defaultDuration.map(UnblockLength.timed) + case .useDefault: defaultDuration(for: group).map(UnblockLength.timed) case .ask: nil } } diff --git a/Normal/Modifiers/WidgetActionResponder.swift b/Normal/Modifiers/WidgetActionResponder.swift index 37c2c2e..6e9505a 100644 --- a/Normal/Modifiers/WidgetActionResponder.swift +++ b/Normal/Modifiers/WidgetActionResponder.swift @@ -129,7 +129,7 @@ private struct WidgetActionResponder: ViewModifier { private func unlock(_ target: UnblockTarget, duration request: UnlockDurationRequest, proof: KeyProof) { guard let grant = UnblockGrant(target, proof: proof) else { return } - guard let settings = allSettings.first, let length = settings.unblockLength(for: request) else { + guard let settings = allSettings.first, let length = settings.unblockLength(for: request, group: target.group) else { durationGrant = grant return } diff --git a/Normal/Resources/Localizable.xcstrings b/Normal/Resources/Localizable.xcstrings index 4311ba0..237279e 100644 --- a/Normal/Resources/Localizable.xcstrings +++ b/Normal/Resources/Localizable.xcstrings @@ -342,6 +342,14 @@ "comment" : "Feature description for a feature row in the \"QR code or barcode examples\" card.", "isCommentAutoGenerated" : true }, + "App Default" : { + "comment" : "The value shown in a group's Default Duration or Default Key row when it follows the default set in Settings.", + "isCommentAutoGenerated" : true + }, + "App Default (%@)" : { + "comment" : "The group picker option that follows the default set in Settings. The argument is that default, such as a duration or key type, or None.", + "isCommentAutoGenerated" : true + }, "App Groups" : { "comment" : "The title of a view that lists app groups.", "isCommentAutoGenerated" : true diff --git a/Normal/Services/UnblockTarget.swift b/Normal/Services/UnblockTarget.swift index de5154d..6627aab 100644 --- a/Normal/Services/UnblockTarget.swift +++ b/Normal/Services/UnblockTarget.swift @@ -12,6 +12,13 @@ enum UnblockTarget: Identifiable { } } + var group: AppGroup? { + if case let .group(group) = self { + return group + } + return nil + } + var groupID: UUID? { if case let .group(group) = self { return group.id diff --git a/Normal/Views/BlockUnblockViews/TimedUnlock/UnblockDurationSheet.swift b/Normal/Views/BlockUnblockViews/TimedUnlock/UnblockDurationSheet.swift index d48f65c..3b77fbc 100644 --- a/Normal/Views/BlockUnblockViews/TimedUnlock/UnblockDurationSheet.swift +++ b/Normal/Views/BlockUnblockViews/TimedUnlock/UnblockDurationSheet.swift @@ -24,7 +24,7 @@ struct UnblockDurationSheet: View { TimedUnblockSheet( title: title, durations: settings.unblockDurations, - initialDuration: settings.defaultDuration, + initialDuration: settings.defaultDuration(for: grant.target.group), onConfirm: { length in let timing = try BlockActions.unblock( grant, diff --git a/Normal/Views/Groups/GroupFormSheet.swift b/Normal/Views/Groups/GroupFormSheet.swift index ebc05a3..0c62799 100644 --- a/Normal/Views/Groups/GroupFormSheet.swift +++ b/Normal/Views/Groups/GroupFormSheet.swift @@ -19,6 +19,8 @@ struct GroupFormSheet: View { @State private var name: String @State private var selection: FamilyActivitySelection @State private var customDomains: [String] + @State private var durationOverride: DefaultOverride + @State private var keyOverride: DefaultOverride @State private var isShowingAppSelectSheet = false @State private var showAddKey = false @State private var showDeleteConfirmation = false @@ -28,6 +30,50 @@ struct GroupFormSheet: View { allKeys.filter { $0.groupID == groupID } } + private var durations: [TimedUnblockDuration] { + allSettings.first?.unblockDurations ?? TimedUnblockDuration.presets + } + + private var groupKeyTypes: [KeyType] { + let keys = Key.scoped(allKeys, toGroup: groupID) + return KeyType.allCases.filter { type in keys.contains { $0.type == type } } + } + + private var appDefaultDurationLabel: String { + allSettings.first?.defaultDuration?.label ?? String(localized: "None") + } + + private var appDefaultKeyLabel: String { + guard let keyType = allSettings.first?.defaultKeyType, groupKeyTypes.contains(keyType) else { + return String(localized: "None") + } + return keyType.label + } + + private var durationSelection: Binding> { + Binding( + get: { + if case let .value(duration) = durationOverride, !durations.contains(duration) { + return .none + } + return durationOverride + }, + set: { durationOverride = $0 } + ) + } + + private var keySelection: Binding> { + Binding( + get: { + if case let .value(keyType) = keyOverride, !groupKeyTypes.contains(keyType) { + return .none + } + return keyOverride + }, + set: { keyOverride = $0 } + ) + } + private var isNew: Bool { existing == nil } @@ -63,6 +109,8 @@ struct GroupFormSheet: View { _name = State(initialValue: existing?.name ?? "") _selection = State(initialValue: existing?.selection ?? FamilyActivitySelection()) _customDomains = State(initialValue: existing?.customDomains ?? []) + _durationOverride = State(initialValue: existing?.durationOverride ?? .appDefault) + _keyOverride = State(initialValue: existing?.keyOverride ?? .appDefault) } var body: some View { @@ -96,6 +144,8 @@ struct GroupFormSheet: View { } } + unblockingSection + if !groupKeys.isEmpty || !isReadOnly { groupKeysSection } @@ -165,6 +215,67 @@ struct GroupFormSheet: View { } } + private var unblockingSection: some View { + Section("Unblocking") { + Group { + if #available(iOS 18.0, *) { + Picker("Default Duration", selection: durationSelection) { + durationOptions(appDefault: String(localized: "App Default (\(appDefaultDurationLabel))")) + } currentValueLabel: { + Text(rowLabel(for: durationSelection.wrappedValue) { $0.label }) + } + } else { + Picker("Default Duration", selection: durationSelection) { + durationOptions(appDefault: String(localized: "App Default")) + } + } + } + .accessibilityIdentifier("groupForm.defaultDuration") + + Group { + if #available(iOS 18.0, *) { + Picker("Default Key", selection: keySelection) { + keyOptions(appDefault: String(localized: "App Default (\(appDefaultKeyLabel))")) + } currentValueLabel: { + Text(rowLabel(for: keySelection.wrappedValue) { $0.label }) + } + } else { + Picker("Default Key", selection: keySelection) { + keyOptions(appDefault: String(localized: "App Default")) + } + } + } + .accessibilityIdentifier("groupForm.defaultKey") + } + .disabled(isReadOnly) + } + + @ViewBuilder + private func durationOptions(appDefault: String) -> some View { + Text(appDefault).tag(DefaultOverride.appDefault) + Text("None").tag(DefaultOverride.none) + ForEach(durations) { duration in + Text(duration.label).tag(DefaultOverride.value(duration)) + } + } + + @ViewBuilder + private func keyOptions(appDefault: String) -> some View { + Text(appDefault).tag(DefaultOverride.appDefault) + Text("None").tag(DefaultOverride.none) + ForEach(groupKeyTypes) { type in + Label(type.label, systemImage: type.icon).tag(DefaultOverride.value(type)) + } + } + + private func rowLabel(for choice: DefaultOverride, value: (Value) -> String) -> String { + switch choice { + case .appDefault: String(localized: "App Default") + case .none: String(localized: "None") + case let .value(chosen): value(chosen) + } + } + private var groupKeysSection: some View { Section { ForEach(groupKeys) { key in @@ -210,6 +321,8 @@ struct GroupFormSheet: View { existing.name = trimmed existing.selection = selection existing.customDomains = storedCustomDomains + existing.durationOverride = durationOverride + existing.keyOverride = keyOverride existing.lastUpdated = .now timedUnblockService.updateGroupSelection( groupId: existing.id, @@ -218,13 +331,16 @@ struct GroupFormSheet: View { ) } else { let nextIndex = SortIndexing.nextIndex(after: allGroups, sortIndex: \.sortIndex) - modelContext.insert(AppGroup( + let group = AppGroup( id: groupID, name: trimmed, selection: selection, sortIndex: nextIndex, customDomains: storedCustomDomains - )) + ) + group.durationOverride = durationOverride + group.keyOverride = keyOverride + modelContext.insert(group) } dismiss() } diff --git a/Normal/Views/Groups/GroupListCardView.swift b/Normal/Views/Groups/GroupListCardView.swift index 063946e..e1c4bb2 100644 --- a/Normal/Views/Groups/GroupListCardView.swift +++ b/Normal/Views/Groups/GroupListCardView.swift @@ -246,7 +246,7 @@ struct GroupListCardView: View { private func unblockGroup(_ proof: KeyProof) { guard let grant = UnblockGrant(.group(appGroup), proof: proof) else { return } - guard let duration = settings.defaultDuration else { + guard let duration = settings.defaultDuration(for: appGroup) else { durationGrant = grant return } diff --git a/Normal/Views/Groups/GroupsView.swift b/Normal/Views/Groups/GroupsView.swift index 0fd3fc1..dd098d2 100644 --- a/Normal/Views/Groups/GroupsView.swift +++ b/Normal/Views/Groups/GroupsView.swift @@ -65,7 +65,9 @@ struct GroupsView: View { // triggered it, instead of on the card row. .protectedAction( $authAction, - defaultKeyType: allSettings.unwrapped.defaultKeyType, + defaultKeyType: allSettings.unwrapped.defaultKeyType( + for: appGroups.first { $0.id == pendingGroupID } + ), keyGroupID: pendingGroupID ) .sheet(item: $durationGrant) { grant in diff --git a/NormalTests/Models/GroupUnblockDefaultsTests.swift b/NormalTests/Models/GroupUnblockDefaultsTests.swift new file mode 100644 index 0000000..d21bf6b --- /dev/null +++ b/NormalTests/Models/GroupUnblockDefaultsTests.swift @@ -0,0 +1,85 @@ +import FamilyControls +import Foundation +@testable import Normal +import Testing + +struct GroupUnblockDefaultsTests { + private let settings = Settings() + private let group = AppGroup(name: "Social", selection: FamilyActivitySelection()) + + @Test func groupsFollowTheAppDefaultsUntilChanged() { + settings.defaultDuration = .thirtyMinutes + settings.defaultKeyType = .nfc + + #expect(group.durationOverride == .appDefault) + #expect(group.keyOverride == .appDefault) + #expect(settings.defaultDuration(for: group) == .thirtyMinutes) + #expect(settings.defaultKeyType(for: group) == .nfc) + #expect(settings.unblockLength(for: .useDefault, group: group) == .timed(.thirtyMinutes)) + } + + @Test func groupDurationOverridesTheAppDefault() { + settings.defaultDuration = .thirtyMinutes + group.durationOverride = .value(.oneHour) + + #expect(settings.defaultDuration(for: group) == .oneHour) + #expect(settings.unblockLength(for: .useDefault, group: group) == .timed(.oneHour)) + #expect(settings.defaultDuration(for: nil) == .thirtyMinutes, "Unblock All keeps the app default") + } + + @Test func groupDurationWorksWithoutAnAppDefault() { + group.durationOverride = .value(.fourHours) + + #expect(settings.defaultDuration == nil) + #expect(settings.defaultDuration(for: group) == .fourHours) + } + + @Test func groupCanTurnOffTheAppDefaultDuration() { + settings.defaultDuration = .thirtyMinutes + group.durationOverride = .none + + #expect(settings.defaultDuration(for: group) == nil) + #expect(settings.unblockLength(for: .useDefault, group: group) == nil) + } + + @Test func groupDurationRemovedFromTheListAsksInsteadOfUsingTheAppDefault() { + settings.defaultDuration = .thirtyMinutes + group.durationOverride = .value(.fourHours) + + settings.removeUnblockDuration(.fourHours) + + #expect(settings.defaultDuration(for: group) == nil) + } + + @Test func requestedDurationsIgnoreTheGroupDefault() { + group.durationOverride = .value(.oneHour) + + #expect(settings.unblockLength(for: .fixed(.fifteenMinutes), group: group) == .timed(.fifteenMinutes)) + #expect(settings.unblockLength(for: .permanent, group: group) == .permanent) + #expect(settings.unblockLength(for: .ask, group: group) == nil) + } + + @Test func groupKeyOverridesTheAppDefaultKey() { + settings.defaultKeyType = .nfc + + group.keyOverride = .value(.location) + #expect(settings.defaultKeyType(for: group) == .location) + + group.keyOverride = .none + #expect(settings.defaultKeyType(for: group) == nil) + #expect(settings.defaultKeyType(for: nil) == .nfc, "Unblock All keeps the app default") + } + + @Test func choosingAppDefaultAgainClearsTheOverride() { + group.durationOverride = .value(.oneHour) + group.keyOverride = .value(.qr) + + group.durationOverride = .appDefault + group.keyOverride = .appDefault + + #expect(!group.overridesDefaultDuration) + #expect(group.defaultUnblockSeconds == nil) + #expect(!group.overridesDefaultKey) + #expect(group.defaultKeyType == nil) + } +} diff --git a/NormalTests/Models/SettingsUnblockDurationTests.swift b/NormalTests/Models/SettingsUnblockDurationTests.swift index 55547be..9cbd4e4 100644 --- a/NormalTests/Models/SettingsUnblockDurationTests.swift +++ b/NormalTests/Models/SettingsUnblockDurationTests.swift @@ -136,28 +136,28 @@ struct SettingsUnblockDurationTests { @Test func fixedRequestUsesItsDuration() { let s = Settings() s.defaultDuration = .thirtyMinutes - #expect(s.unblockLength(for: .fixed(.fourHours)) == .timed(.fourHours)) + #expect(s.unblockLength(for: .fixed(.fourHours), group: nil) == .timed(.fourHours)) } @Test func defaultRequestUsesDefaultDuration() { let s = Settings() s.defaultDuration = .thirtyMinutes - #expect(s.unblockLength(for: .useDefault) == .timed(.thirtyMinutes)) + #expect(s.unblockLength(for: .useDefault, group: nil) == .timed(.thirtyMinutes)) } @Test func defaultRequestWithoutDefaultHasNoDuration() { - #expect(Settings().unblockLength(for: .useDefault) == nil) + #expect(Settings().unblockLength(for: .useDefault, group: nil) == nil) } @Test func askRequestHasNoDuration() { let s = Settings() s.defaultDuration = .thirtyMinutes - #expect(s.unblockLength(for: .ask) == nil) + #expect(s.unblockLength(for: .ask, group: nil) == nil) } @Test func permanentRequestIsPermanent() { let s = Settings() s.defaultDuration = .thirtyMinutes - #expect(s.unblockLength(for: .permanent) == .permanent) + #expect(s.unblockLength(for: .permanent, group: nil) == .permanent) } } diff --git a/NormalTests/Models/StoreUpgradeTests.swift b/NormalTests/Models/StoreUpgradeTests.swift index 1c1d79e..37a7e0d 100644 --- a/NormalTests/Models/StoreUpgradeTests.swift +++ b/NormalTests/Models/StoreUpgradeTests.swift @@ -318,6 +318,8 @@ struct StoreUpgradeTests { #expect(group.lastUpdated == Self.updated) #expect(group.sortIndex == 2) #expect(group.customDomains == ["reddit.com"]) + #expect(group.durationOverride == .appDefault) + #expect(group.keyOverride == .appDefault) let main = try #require(try context.fetch(FetchDescriptor()).first) #expect(main.selection == TokenFixtures.selection(apps: [1, 2, 3], webDomains: [1])) diff --git a/NormalTests/Services/AppUnblockIntentPerformerTests.swift b/NormalTests/Services/AppUnblockIntentPerformerTests.swift index e47f6f6..e3e3caf 100644 --- a/NormalTests/Services/AppUnblockIntentPerformerTests.swift +++ b/NormalTests/Services/AppUnblockIntentPerformerTests.swift @@ -209,6 +209,18 @@ struct AppUnblockIntentPerformerTests { #expect(inbox.pending?.keyType == .location) } + @Test func continueInAppUsesTheGroupsDefaultKey() throws { + let settings = try seed() + settings.defaultKeyType = .qr + let group = try seedGroup() + group.keyOverride = .value(.location) + context.insert(locationKey(groupID: group.id)) + + performer.continueInApp(request(group: group.id, key: nil)) + + #expect(inbox.pending?.keyType == .location) + } + @Test func continueInAppUsesTheOnlyKeyType() throws { try seed() @@ -378,6 +390,20 @@ struct AppUnblockIntentPerformerTests { #expect(timedUnblock.isGroupUnblockActive(groupId: group.id)) } + @Test func groupLocationUnblockUsesTheGroupsDefaultDuration() async throws { + let settings = try seed() + settings.defaultDuration = .thirtyMinutes + let group = try seedGroup() + group.durationOverride = .value(.fourHours) + context.insert(locationKey(groupID: group.id)) + screenTime.stubBlockStatus = .all + + #expect( + try await performer.unblock(locationRequest(group: group.id, duration: .useDefault)) + == .unblocked(name: "Social", length: .timed(.fourHours)) + ) + } + @Test func failingToStartTheUnblockThrows() async throws { try seed() context.insert(locationKey()) diff --git a/NormalUITests/BlockingUITests.swift b/NormalUITests/BlockingUITests.swift index e58d24a..b6680cd 100644 --- a/NormalUITests/BlockingUITests.swift +++ b/NormalUITests/BlockingUITests.swift @@ -277,6 +277,44 @@ final class BlockingUITests: XCTestCase { XCTAssertFalse(app.descendants(matching: .any)["schedule.weekdayChips"].exists) } + func testGroupDefaultDurationSkipsTheDurationSheet() { + let app = launch(["-uiTestSeedGroupKey"]) + app.mainTab("Groups").tap() + + let group = app.staticTexts["Test Group"] + require(group, "Seeded group should render") + group.tap() + + let picker = app.buttons["groupForm.defaultDuration"] + require(picker, "Edit Group should offer a default duration") + picker.tap() + if #available(iOS 18.0, *) { + XCTAssertTrue(app.buttons["App Default (None)"].waitForExistence(timeout: timeout), "The menu should say what App Default is") + } + let fourHours = app.buttons["4 hours"] + require(fourHours, "The menu should list the unblock durations") + fourHours.tap() + app.buttons["Update"].tap() + + let blockButton = app.buttons["group.blockButton"] + require(blockButton, "Group block button should render") + blockButton.tap() + let bypass = app.buttons["keySelect.blockWithoutKey"] + require(bypass, "Group block should offer bypass") + bypass.tap() + confirmBypass(app) + + let unblockButton = app.buttons["group.unblockButton"] + require(unblockButton, "Group unblock button should render after blocking") + unblockButton.tap() + let keyRow = app.buttons["keySelect.row.QR"] + require(keyRow, "Unblocking the group should ask for a key") + keyRow.tap() + + require(app.staticTexts["Timed Unblock"], "The group's default should start the unblock") + XCTAssertFalse(app.buttons["timedUnblock.confirm"].exists, "The group's default should skip the duration sheet") + } + func testFailedDefaultDurationUnblockShowsError() { let app = launch(["-uiTestDefaultDuration", "900", "-uiTestTimedUnblockFails"]) blockViaBypass(app)