Initial service implementation for using a PIN code. (#1912)

* Initial service implementation for using a PIN code. * Tweak Danger for commit size 600-800 lines is perfectly normal for our PRs, up it to 1000.
2026-11-02 21:33:26 +00:00 · 2023-10-19 10:42:12 +01:00
parent fbcf037240
commit 99c28784a9
14 changed files with 730 additions and 35 deletions
@@ -0,0 +1,154 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+
+@testable import ElementX
+
+class AppLockTimerTests: XCTestCase {
+    var timer: AppLockTimer!
+    
+    let now = Date.now
+    
+    var gracePeriod: TimeInterval { timer.gracePeriod }
+    var halfGracePeriod: TimeInterval { gracePeriod / 2 }
+    var gracePeriodX2: TimeInterval { gracePeriod * 2 }
+    var gracePeriodX10: TimeInterval { gracePeriod * 10 }
+    
+    override func tearDown() {
+        timer = nil
+    }
+    
+    func testTimerLockedOnStartup() {
+        setupTimer(unlocked: false)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now),
+                      "The app should be locked on a fresh launch.")
+        
+        setupTimer(unlocked: false)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + 1),
+                      "The app should be locked after a fresh launch.")
+        
+        setupTimer(unlocked: false)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + halfGracePeriod),
+                      "The app should be locked after a fresh launch.")
+        
+        setupTimer(unlocked: false)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriod),
+                      "The app should be locked after a fresh launch.")
+        
+        setupTimer(unlocked: false)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriodX10),
+                      "The app should be locked after a fresh launch.")
+    }
+    
+    func testTimerBeforeFirstUnlock() {
+        setupTimer(unlocked: false, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now),
+                      "The app should always remain locked after backgrounding when locked.")
+        
+        setupTimer(unlocked: false, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + 1),
+                      "The app should always remain locked after backgrounding when locked.")
+        
+        setupTimer(unlocked: false, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + halfGracePeriod),
+                      "The app should always remain locked after backgrounding when locked.")
+        
+        setupTimer(unlocked: false, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriod),
+                      "The app should always remain locked after backgrounding when locked.")
+        
+        setupTimer(unlocked: false, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriodX10),
+                      "The app should always remain locked after backgrounding when locked.")
+    }
+    
+    func testTimerWhenUnlocked() {
+        setupTimer(unlocked: true, backgroundedAt: now)
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: now + 1),
+                       "The app should remain unlocked when it was unlocked and backgrounded for less then the grace period.")
+        
+        setupTimer(unlocked: true, backgroundedAt: now)
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: now + halfGracePeriod),
+                       "The app should remain unlocked when it was unlocked and backgrounded for less then the grace period.")
+        
+        setupTimer(unlocked: true, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriod),
+                      "The app should become locked when it was unlocked and backgrounded for more than the grace period.")
+        
+        setupTimer(unlocked: true, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now + gracePeriodX10),
+                      "The app should become locked when it was unlocked and backgrounded for more than the grace period.")
+    }
+    
+    func testTimerRepeatingWithinGracePeriod() {
+        setupTimer(unlocked: true, backgroundedAt: now)
+        
+        var nextCheck = now + halfGracePeriod
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: nextCheck),
+                       "The app should remain unlocked when it was unlocked and backgrounded for less then the grace period.")
+        timer.applicationDidEnterBackground(date: nextCheck)
+        
+        nextCheck = now + gracePeriod
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: nextCheck),
+                       "The app should remain unlocked when repeating the backgrounded and foreground within the grace period.")
+        timer.applicationDidEnterBackground(date: nextCheck)
+        
+        nextCheck = now + gracePeriod + halfGracePeriod
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: nextCheck),
+                       "The app should remain unlocked when repeating the backgrounded and foreground within the grace period.")
+        timer.applicationDidEnterBackground(date: nextCheck)
+        
+        nextCheck = now + gracePeriodX2
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: nextCheck),
+                       "The app should remain unlocked when repeating the backgrounded and foreground within the grace period.")
+        timer.applicationDidEnterBackground(date: nextCheck)
+        
+        nextCheck = now + gracePeriodX10
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: nextCheck),
+                      "The app should become locked however when finally staying backgrounded for longer than the grace period.")
+    }
+    
+    func testTimerWithLongForeground() {
+        setupTimer(unlocked: true)
+        
+        let backgroundDate = now + gracePeriodX10
+        timer.applicationDidEnterBackground(date: backgroundDate)
+        
+        XCTAssertFalse(timer.computeLockState(willEnterForegroundAt: backgroundDate + 1),
+                       "The grace period should be measured from the time the app was backgrounded, and not when it was unlocked.")
+    }
+    
+    func testChangingTimeLocksApp() {
+        setupTimer(unlocked: true, backgroundedAt: now)
+        XCTAssertTrue(timer.computeLockState(willEnterForegroundAt: now - 1),
+                      "The the device's clock is changed to before the app was backgrounded, the device should remain locked.")
+    }
+    
+    /// Sets up the timer for testing.
+    /// - Parameters:
+    ///   - unlocked: Whether the timer should consider itself unlocked or not.
+    ///   - backgroundedDate: If not nil, the timer will consider the app to have been backgrounded at the specified date.
+    private func setupTimer(unlocked: Bool, backgroundedAt backgroundedDate: Date? = nil) {
+        timer = AppLockTimer(gracePeriod: 180)
+        if unlocked {
+            timer.registerUnlock()
+        }
+        if let backgroundedDate {
+            timer.applicationDidEnterBackground(date: backgroundedDate)
+        }
+    }
+}