824 lines
23 KiB
Swift
824 lines
23 KiB
Swift
// swiftlint:disable discouraged_optional_boolean
|
|
import Foundation
|
|
import Combine
|
|
import XCTest
|
|
@testable import Defaults
|
|
|
|
let fixtureURL = URL(string: "https://sindresorhus.com")!
|
|
let fixtureFileURL = URL(string: "file://~/icon.png")!
|
|
let fixtureURL2 = URL(string: "https://example.com")!
|
|
let fixtureDate = Date()
|
|
|
|
extension Defaults.Keys {
|
|
static let key = Key<Bool>("key", default: false)
|
|
static let url = Key<URL>("url", default: fixtureURL)
|
|
static let file = Key<URL>("fileURL", default: fixtureFileURL)
|
|
static let data = Key<Data>("data", default: Data([]))
|
|
static let date = Key<Date>("date", default: fixtureDate)
|
|
static let uuid = Key<UUID?>("uuid")
|
|
static let defaultDynamicDate = Key<Date>("defaultDynamicOptionalDate") { Date(timeIntervalSince1970: 0) }
|
|
static let defaultDynamicOptionalDate = Key<Date?>("defaultDynamicOptionalDate") { Date(timeIntervalSince1970: 1) }
|
|
}
|
|
|
|
final class DefaultsTests: XCTestCase {
|
|
override func setUp() {
|
|
super.setUp()
|
|
Defaults.removeAll()
|
|
}
|
|
|
|
override func tearDown() {
|
|
super.tearDown()
|
|
Defaults.removeAll()
|
|
}
|
|
|
|
func testKey() {
|
|
let key = Defaults.Key<Bool>("independentKey", default: false)
|
|
XCTAssertFalse(Defaults[key])
|
|
Defaults[key] = true
|
|
XCTAssertTrue(Defaults[key])
|
|
}
|
|
|
|
func testValidKeyName() {
|
|
let validKey = Defaults.Key<Bool>("test", default: false)
|
|
let containsDotKey = Defaults.Key<Bool>("test.a", default: false)
|
|
let startsWithAtKey = Defaults.Key<Bool>("@test", default: false)
|
|
XCTAssertTrue(Defaults.isValidKeyPath(name: validKey.name))
|
|
XCTAssertFalse(Defaults.isValidKeyPath(name: containsDotKey.name))
|
|
XCTAssertFalse(Defaults.isValidKeyPath(name: startsWithAtKey.name))
|
|
}
|
|
|
|
func testOptionalKey() {
|
|
let key = Defaults.Key<Bool?>("independentOptionalKey")
|
|
let url = Defaults.Key<URL?>("independentOptionalURLKey")
|
|
XCTAssertNil(Defaults[key])
|
|
XCTAssertNil(Defaults[url])
|
|
Defaults[key] = true
|
|
Defaults[url] = fixtureURL
|
|
XCTAssertTrue(Defaults[key]!)
|
|
XCTAssertEqual(Defaults[url], fixtureURL)
|
|
Defaults[key] = nil
|
|
Defaults[url] = nil
|
|
XCTAssertNil(Defaults[key])
|
|
XCTAssertNil(Defaults[url])
|
|
Defaults[key] = false
|
|
Defaults[url] = fixtureURL2
|
|
XCTAssertFalse(Defaults[key]!)
|
|
XCTAssertEqual(Defaults[url], fixtureURL2)
|
|
}
|
|
|
|
func testInitializeDynamicDateKey() {
|
|
_ = Defaults.Key<Date>("independentInitializeDynamicDateKey") {
|
|
XCTFail("Init dynamic key should not trigger getter")
|
|
return Date()
|
|
}
|
|
_ = Defaults.Key<Date?>("independentInitializeDynamicOptionalDateKey") {
|
|
XCTFail("Init dynamic optional key should not trigger getter")
|
|
return Date()
|
|
}
|
|
}
|
|
|
|
func testKeyRegistersDefault() {
|
|
let keyName = "registersDefault"
|
|
XCTAssertFalse(UserDefaults.standard.bool(forKey: keyName))
|
|
_ = Defaults.Key<Bool>(keyName, default: true)
|
|
XCTAssertTrue(UserDefaults.standard.bool(forKey: keyName))
|
|
|
|
// Test that it works with multiple keys with `Defaults`.
|
|
let keyName2 = "registersDefault2"
|
|
_ = Defaults.Key<String>(keyName2, default: keyName2)
|
|
XCTAssertEqual(UserDefaults.standard.string(forKey: keyName2), keyName2)
|
|
}
|
|
|
|
func testKeyWithUserDefaultSubscript() {
|
|
let key = Defaults.Key<Bool>("keyWithUserDeaultSubscript", default: false)
|
|
XCTAssertFalse(UserDefaults.standard[key])
|
|
UserDefaults.standard[key] = true
|
|
XCTAssertTrue(UserDefaults.standard[key])
|
|
}
|
|
|
|
func testKeys() {
|
|
XCTAssertFalse(Defaults[.key])
|
|
Defaults[.key] = true
|
|
XCTAssertTrue(Defaults[.key])
|
|
}
|
|
|
|
func testUrlType() {
|
|
XCTAssertEqual(Defaults[.url], fixtureURL)
|
|
let newUrl = URL(string: "https://twitter.com")!
|
|
Defaults[.url] = newUrl
|
|
XCTAssertEqual(Defaults[.url], newUrl)
|
|
}
|
|
|
|
func testDataType() {
|
|
XCTAssertEqual(Defaults[.data], Data([]))
|
|
let newData = Data([0xFF])
|
|
Defaults[.data] = newData
|
|
XCTAssertEqual(Defaults[.data], newData)
|
|
}
|
|
|
|
func testDateType() {
|
|
XCTAssertEqual(Defaults[.date], fixtureDate)
|
|
let newDate = Date()
|
|
Defaults[.date] = newDate
|
|
XCTAssertEqual(Defaults[.date], newDate)
|
|
}
|
|
|
|
func testDynamicDateType() {
|
|
XCTAssertEqual(Defaults[.defaultDynamicDate], Date(timeIntervalSince1970: 0))
|
|
let next = Date(timeIntervalSince1970: 1)
|
|
Defaults[.defaultDynamicDate] = next
|
|
XCTAssertEqual(Defaults[.defaultDynamicDate], next)
|
|
XCTAssertEqual(UserDefaults.standard.object(forKey: Defaults.Key<Date>.defaultDynamicDate.name) as! Date, next)
|
|
Defaults.Key<Date>.defaultDynamicDate.reset()
|
|
XCTAssertEqual(Defaults[.defaultDynamicDate], Date(timeIntervalSince1970: 0))
|
|
}
|
|
|
|
func testDynamicOptionalDateType() {
|
|
XCTAssertEqual(Defaults[.defaultDynamicOptionalDate], Date(timeIntervalSince1970: 1))
|
|
let next = Date(timeIntervalSince1970: 2)
|
|
Defaults[.defaultDynamicOptionalDate] = next
|
|
XCTAssertEqual(Defaults[.defaultDynamicOptionalDate], next)
|
|
XCTAssertEqual(UserDefaults.standard.object(forKey: Defaults.Key<Date>.defaultDynamicOptionalDate.name) as! Date, next)
|
|
Defaults[.defaultDynamicOptionalDate] = nil
|
|
XCTAssertEqual(Defaults[.defaultDynamicOptionalDate], Date(timeIntervalSince1970: 1))
|
|
XCTAssertNil(UserDefaults.standard.object(forKey: Defaults.Key<Date>.defaultDynamicOptionalDate.name))
|
|
}
|
|
|
|
func testFileURLType() {
|
|
XCTAssertEqual(Defaults[.file], fixtureFileURL)
|
|
}
|
|
|
|
func testUUIDType() {
|
|
let fixture = UUID()
|
|
Defaults[.uuid] = fixture
|
|
XCTAssertEqual(Defaults[.uuid], fixture)
|
|
}
|
|
|
|
func testRemoveAll() {
|
|
let key = Defaults.Key<Bool>("removeAll", default: false)
|
|
let key2 = Defaults.Key<Bool>("removeAll2", default: false)
|
|
Defaults[key] = true
|
|
Defaults[key2] = true
|
|
XCTAssertTrue(Defaults[key])
|
|
XCTAssertTrue(Defaults[key2])
|
|
Defaults.removeAll()
|
|
XCTAssertFalse(Defaults[key])
|
|
XCTAssertFalse(Defaults[key2])
|
|
}
|
|
|
|
func testCustomSuite() {
|
|
let customSuite = UserDefaults(suiteName: "com.sindresorhus.customSuite")!
|
|
let key = Defaults.Key<Bool>("customSuite", default: false, suite: customSuite)
|
|
XCTAssertFalse(customSuite[key])
|
|
XCTAssertFalse(Defaults[key])
|
|
Defaults[key] = true
|
|
XCTAssertTrue(customSuite[key])
|
|
XCTAssertTrue(Defaults[key])
|
|
Defaults.removeAll(suite: customSuite)
|
|
}
|
|
|
|
func testIsDefaultValue() {
|
|
let key = Defaults.Key<Bool>("isDefaultValue", default: false)
|
|
XCTAssert(key.isDefaultValue)
|
|
Defaults[key].toggle()
|
|
XCTAssert(!key.isDefaultValue)
|
|
}
|
|
|
|
func testObserveKeyCombine() {
|
|
let key = Defaults.Key<Bool>("observeKey", default: false)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults
|
|
.publisher(key, options: [])
|
|
.map { ($0.oldValue, $0.newValue) }
|
|
.collect(2)
|
|
|
|
let cancellable = publisher.sink { tuples in
|
|
for (index, expected) in [(false, true), (true, false)].enumerated() {
|
|
XCTAssertEqual(expected.0, tuples[index].0)
|
|
XCTAssertEqual(expected.1, tuples[index].1)
|
|
}
|
|
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = true
|
|
Defaults.reset(key)
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveOptionalKeyCombine() {
|
|
let key = Defaults.Key<Bool?>("observeOptionalKey")
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults
|
|
.publisher(key, options: [])
|
|
.map { ($0.oldValue, $0.newValue) }
|
|
.collect(3)
|
|
|
|
let expectedValues: [(Bool?, Bool?)] = [(nil, true), (true, false), (false, nil)]
|
|
|
|
let cancellable = publisher.sink { actualValues in
|
|
for (expected, actual) in zip(expectedValues, actualValues) {
|
|
XCTAssertEqual(expected.0, actual.0)
|
|
XCTAssertEqual(expected.1, actual.1)
|
|
}
|
|
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = true
|
|
Defaults[key] = false
|
|
Defaults.reset(key)
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testDynamicOptionalDateTypeCombine() {
|
|
let first = Date(timeIntervalSince1970: 0)
|
|
let second = Date(timeIntervalSince1970: 1)
|
|
let third = Date(timeIntervalSince1970: 2)
|
|
let key = Defaults.Key<Date?>("combineDynamicOptionalDateKey") { first }
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults
|
|
.publisher(key, options: [])
|
|
.map { ($0.oldValue, $0.newValue) }
|
|
.collect(3)
|
|
|
|
let expectedValues: [(Date?, Date?)] = [(first, second), (second, third), (third, first)]
|
|
|
|
let cancellable = publisher.sink { actualValues in
|
|
for (expected, actual) in zip(expectedValues, actualValues) {
|
|
XCTAssertEqual(expected.0, actual.0)
|
|
XCTAssertEqual(expected.1, actual.1)
|
|
}
|
|
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = second
|
|
Defaults[key] = third
|
|
Defaults.reset(key)
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveMultipleKeysCombine() {
|
|
let key1 = Defaults.Key<String>("observeKey1", default: "x")
|
|
let key2 = Defaults.Key<Bool>("observeKey2", default: true)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults.publisher(keys: key1, key2, options: []).collect(2)
|
|
|
|
let cancellable = publisher.sink { _ in
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = "y"
|
|
Defaults[key2] = false
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveMultipleOptionalKeysCombine() {
|
|
let key1 = Defaults.Key<String?>("observeOptionalKey1")
|
|
let key2 = Defaults.Key<Bool?>("observeOptionalKey2")
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults.publisher(keys: key1, key2, options: []).collect(2)
|
|
|
|
let cancellable = publisher.sink { _ in
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = "x"
|
|
Defaults[key2] = false
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testReceiveValueBeforeSubscriptionCombine() {
|
|
let key = Defaults.Key<String>("receiveValueBeforeSubscription", default: "hello")
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let publisher = Defaults
|
|
.publisher(key)
|
|
.map(\.newValue)
|
|
.eraseToAnyPublisher()
|
|
.collect(2)
|
|
|
|
let cancellable = publisher.sink { values in
|
|
XCTAssertEqual(["hello", "world"], values)
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = "world"
|
|
cancellable.cancel()
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveKey() {
|
|
let key = Defaults.Key<Bool>("observeKey", default: false)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key, options: []) { change in
|
|
XCTAssertFalse(change.oldValue)
|
|
XCTAssertTrue(change.newValue)
|
|
observation.invalidate()
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = true
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveOptionalKey() {
|
|
let key = Defaults.Key<Bool?>("observeOptionalKey")
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key, options: []) { change in
|
|
XCTAssertNil(change.oldValue)
|
|
XCTAssertTrue(change.newValue!)
|
|
observation.invalidate()
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = true
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveMultipleKeys() {
|
|
let key1 = Defaults.Key<String>("observeKey1", default: "x")
|
|
let key2 = Defaults.Key<Bool>("observeKey2", default: true)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
var observation: Defaults.Observation!
|
|
var counter = 0
|
|
observation = Defaults.observe(keys: key1, key2, options: []) {
|
|
counter += 1
|
|
if counter == 2 {
|
|
expect.fulfill()
|
|
} else if counter > 2 {
|
|
XCTFail() // swiftlint:disable:this xctfail_message
|
|
}
|
|
}
|
|
|
|
Defaults[key1] = "y"
|
|
Defaults[key2] = false
|
|
observation.invalidate()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveKeyURL() {
|
|
let key = Defaults.Key<URL>("observeKeyURL", default: fixtureURL)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key, options: []) { change in
|
|
XCTAssertEqual(change.oldValue, fixtureURL)
|
|
XCTAssertEqual(change.newValue, fixtureURL2)
|
|
observation.invalidate()
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = fixtureURL2
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveDynamicOptionalDateKey() {
|
|
let first = Date(timeIntervalSince1970: 0)
|
|
let second = Date(timeIntervalSince1970: 1)
|
|
let key = Defaults.Key<Date?>("observeDynamicOptionalDate") { first }
|
|
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key, options: []) { change in
|
|
XCTAssertEqual(change.oldValue, first)
|
|
XCTAssertEqual(change.newValue, second)
|
|
observation.invalidate()
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key] = second
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObservePreventPropagation() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation0", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var observation: Defaults.Observation!
|
|
var wasInside = false
|
|
observation = Defaults.observe(key1, options: []) { _ in
|
|
XCTAssertFalse(wasInside)
|
|
wasInside = true
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1] = true
|
|
}
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = false
|
|
observation.invalidate()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObservePreventPropagationMultipleKeys() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation1", default: nil)
|
|
let key2 = Defaults.Key<Bool?>("preventPropagation2", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var observation: Defaults.Observation!
|
|
var wasInside = false
|
|
observation = Defaults.observe(keys: key1, key2, options: []) {
|
|
XCTAssertFalse(wasInside)
|
|
wasInside = true
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1] = true
|
|
}
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = false
|
|
observation.invalidate()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
// This checks if the callback is still being called if the value is changed on a second thread while the initial thread is doing some long running task.
|
|
func testObservePreventPropagationMultipleThreads() {
|
|
let key1 = Defaults.Key<Int?>("preventPropagation3", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key1, options: []) { _ in
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1]! += 1
|
|
}
|
|
print("--- Main Thread: \(Thread.isMainThread)")
|
|
if !Thread.isMainThread {
|
|
XCTAssertEqual(Defaults[key1]!, 4)
|
|
expect.fulfill()
|
|
} else {
|
|
usleep(300_000)
|
|
print("--- Release: \(Thread.isMainThread)")
|
|
}
|
|
}
|
|
DispatchQueue.global().asyncAfter(deadline: .now() + 0.05) {
|
|
Defaults[key1]! += 1
|
|
}
|
|
Defaults[key1] = 1
|
|
observation.invalidate()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
// Check if propagation prevention works across multiple observations.
|
|
func testObservePreventPropagationMultipleObservations() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation4", default: nil)
|
|
let key2 = Defaults.Key<Bool?>("preventPropagation5", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
let observation1 = Defaults.observe(key2, options: []) { _ in
|
|
XCTFail() // swiftlint:disable:this xctfail_message
|
|
}
|
|
|
|
let observation2 = Defaults.observe(keys: key1, key2, options: []) {
|
|
Defaults.withoutPropagation {
|
|
Defaults[key2] = true
|
|
}
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = false
|
|
observation1.invalidate()
|
|
observation2.invalidate()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObservePreventPropagationCombine() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation6", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var wasInside = false
|
|
let cancellable = Defaults.publisher(key1, options: []).sink { _ in
|
|
XCTAssertFalse(wasInside)
|
|
wasInside = true
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1] = true
|
|
}
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key1] = false
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObservePreventPropagationMultipleKeysCombine() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation7", default: nil)
|
|
let key2 = Defaults.Key<Bool?>("preventPropagation8", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var wasInside = false
|
|
let cancellable = Defaults.publisher(keys: key1, key2, options: []).sink { _ in
|
|
XCTAssertFalse(wasInside)
|
|
wasInside = true
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1] = true
|
|
}
|
|
expect.fulfill()
|
|
}
|
|
|
|
Defaults[key2] = false
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObservePreventPropagationModifiersCombine() {
|
|
let key1 = Defaults.Key<Bool?>("preventPropagation9", default: nil)
|
|
let expect = expectation(description: "No infinite recursion")
|
|
|
|
var wasInside = false
|
|
var cancellable: AnyCancellable!
|
|
cancellable = Defaults.publisher(key1, options: [])
|
|
.receive(on: DispatchQueue.main)
|
|
.delay(for: 0.5, scheduler: DispatchQueue.global())
|
|
.sink { _ in
|
|
XCTAssertFalse(wasInside)
|
|
wasInside = true
|
|
Defaults.withoutPropagation {
|
|
Defaults[key1] = true
|
|
}
|
|
expect.fulfill()
|
|
cancellable.cancel()
|
|
}
|
|
|
|
Defaults[key1] = false
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testRemoveDuplicatesObserveKeyCombine() {
|
|
let key = Defaults.Key<Bool>("observeKey", default: false)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let inputArray = [true, false, false, false, false, false, false, true]
|
|
let expectedArray = [true, false, true]
|
|
|
|
let cancellable = Defaults
|
|
.publisher(key, options: [])
|
|
.removeDuplicates()
|
|
.map(\.newValue)
|
|
.collect(expectedArray.count)
|
|
.sink { result in
|
|
print("Result array: \(result)")
|
|
|
|
if result == expectedArray {
|
|
expect.fulfill()
|
|
} else {
|
|
XCTFail("Expected Array is not matched")
|
|
}
|
|
}
|
|
|
|
for item in inputArray {
|
|
Defaults[key] = item
|
|
}
|
|
|
|
Defaults.reset(key)
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testRemoveDuplicatesOptionalObserveKeyCombine() {
|
|
let key = Defaults.Key<Bool?>("observeOptionalKey", default: nil)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
let inputArray = [true, nil, nil, nil, false, false, false, nil]
|
|
let expectedArray = [true, nil, false, nil]
|
|
|
|
let cancellable = Defaults
|
|
.publisher(key, options: [])
|
|
.removeDuplicates()
|
|
.map(\.newValue)
|
|
.collect(expectedArray.count)
|
|
.sink { result in
|
|
print("Result array: \(result)")
|
|
|
|
if result == expectedArray {
|
|
expect.fulfill()
|
|
} else {
|
|
XCTFail("Expected Array is not matched")
|
|
}
|
|
}
|
|
|
|
for item in inputArray {
|
|
Defaults[key] = item
|
|
}
|
|
|
|
Defaults.reset(key)
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testResetKey() {
|
|
let defaultFixture1 = "foo1"
|
|
let defaultFixture2 = 0
|
|
let newFixture1 = "bar1"
|
|
let newFixture2 = 1
|
|
let key1 = Defaults.Key<String>("key1", default: defaultFixture1)
|
|
let key2 = Defaults.Key<Int>("key2", default: defaultFixture2)
|
|
Defaults[key1] = newFixture1
|
|
Defaults[key2] = newFixture2
|
|
Defaults.reset(key1)
|
|
XCTAssertEqual(Defaults[key1], defaultFixture1)
|
|
XCTAssertEqual(Defaults[key2], newFixture2)
|
|
}
|
|
|
|
func testResetMultipleKeys() {
|
|
let defaultFxiture1 = "foo1"
|
|
let defaultFixture2 = 0
|
|
let defaultFixture3 = "foo3"
|
|
let newFixture1 = "bar1"
|
|
let newFixture2 = 1
|
|
let newFixture3 = "bar3"
|
|
let key1 = Defaults.Key<String>("akey1", default: defaultFxiture1)
|
|
let key2 = Defaults.Key<Int>("akey2", default: defaultFixture2)
|
|
let key3 = Defaults.Key<String>("akey3", default: defaultFixture3)
|
|
Defaults[key1] = newFixture1
|
|
Defaults[key2] = newFixture2
|
|
Defaults[key3] = newFixture3
|
|
Defaults.reset(key1, key2)
|
|
XCTAssertEqual(Defaults[key1], defaultFxiture1)
|
|
XCTAssertEqual(Defaults[key2], defaultFixture2)
|
|
XCTAssertEqual(Defaults[key3], newFixture3)
|
|
}
|
|
|
|
func testResetMultipleOptionalKeys() {
|
|
let newFixture1 = "bar1"
|
|
let newFixture2 = 1
|
|
let newFixture3 = "bar3"
|
|
let key1 = Defaults.Key<String?>("aoptionalKey1")
|
|
let key2 = Defaults.Key<Int?>("aoptionalKey2")
|
|
let key3 = Defaults.Key<String?>("aoptionalKey3")
|
|
Defaults[key1] = newFixture1
|
|
Defaults[key2] = newFixture2
|
|
Defaults[key3] = newFixture3
|
|
Defaults.reset(key1, key2)
|
|
XCTAssertNil(Defaults[key1])
|
|
XCTAssertNil(Defaults[key2])
|
|
XCTAssertEqual(Defaults[key3], newFixture3)
|
|
}
|
|
|
|
func testObserveWithLifetimeTie() {
|
|
let key = Defaults.Key<Bool>("lifetimeTie", default: false)
|
|
let expect = expectation(description: "Observation closure being called")
|
|
|
|
weak var observation: Defaults.Observation!
|
|
observation = Defaults.observe(key, options: []) { _ in
|
|
observation.invalidate()
|
|
expect.fulfill()
|
|
}
|
|
.tieToLifetime(of: self)
|
|
|
|
Defaults[key] = true
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testObserveWithLifetimeTieManualBreak() {
|
|
let key = Defaults.Key<Bool>("lifetimeTieManualBreak", default: false)
|
|
|
|
weak var observation: Defaults.Observation? = Defaults.observe(key, options: []) { _ in }.tieToLifetime(of: self)
|
|
observation!.removeLifetimeTie()
|
|
|
|
for index in 1...10 {
|
|
if observation == nil {
|
|
break
|
|
}
|
|
|
|
sleep(1)
|
|
|
|
if index == 10 {
|
|
XCTFail() // swiftlint:disable:this xctfail_message
|
|
}
|
|
}
|
|
}
|
|
|
|
func testImmediatelyFinishingPublisherCombine() {
|
|
let key = Defaults.Key<Bool>("observeKey", default: false)
|
|
let expect = expectation(description: "Observation closure being called without crashing")
|
|
|
|
let cancellable = Defaults
|
|
.publisher(key, options: [.initial])
|
|
.first()
|
|
.sink { _ in
|
|
expect.fulfill()
|
|
}
|
|
|
|
cancellable.cancel()
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testImmediatelyFinishingMultiplePublisherCombine() {
|
|
let key1 = Defaults.Key<Bool>("observeKey1", default: false)
|
|
let key2 = Defaults.Key<String>("observeKey2", default: "🦄")
|
|
let expect = expectation(description: "Observation closure being called without crashing")
|
|
|
|
let cancellable = Defaults
|
|
.publisher(keys: [key1, key2], options: [.initial])
|
|
.first()
|
|
.sink { _ in
|
|
expect.fulfill()
|
|
}
|
|
|
|
cancellable.cancel()
|
|
|
|
waitForExpectations(timeout: 10)
|
|
}
|
|
|
|
func testKeyEquatable() {
|
|
XCTAssertEqual(Defaults.Key<Bool>("equatableKeyTest", default: false), Defaults.Key<Bool>("equatableKeyTest", default: false))
|
|
}
|
|
|
|
func testKeyHashable() {
|
|
_ = Set([Defaults.Key<Bool>("hashableKeyTest", default: false)])
|
|
}
|
|
|
|
func testUpdates() async {
|
|
let key = Defaults.Key<Bool>("updatesKey", default: false)
|
|
|
|
async let waiter = Defaults.updates(key, initial: false).first { $0 }
|
|
|
|
try? await Task.sleep(for: .seconds(0.1))
|
|
|
|
Defaults[key] = true
|
|
|
|
guard let result = await waiter else {
|
|
XCTFail() // swiftlint:disable:this xctfail_message
|
|
return
|
|
}
|
|
|
|
XCTAssertTrue(result)
|
|
}
|
|
|
|
func testUpdatesMultipleKeys() async {
|
|
let key1 = Defaults.Key<Bool>("updatesMultipleKey1", default: false)
|
|
let key2 = Defaults.Key<Bool>("updatesMultipleKey2", default: false)
|
|
let counter = Counter()
|
|
|
|
async let waiter: Void = {
|
|
for await _ in Defaults.updates([key1, key2], initial: false) {
|
|
await counter.increment()
|
|
|
|
if await counter.count == 2 {
|
|
break
|
|
}
|
|
}
|
|
}()
|
|
|
|
try? await Task.sleep(for: .seconds(0.1))
|
|
|
|
Defaults[key1] = true
|
|
Defaults[key2] = true
|
|
|
|
await waiter
|
|
|
|
let count = await counter.count
|
|
XCTAssertEqual(count, 2)
|
|
}
|
|
}
|
|
|
|
actor Counter {
|
|
private var _count = 0
|
|
|
|
var count: Int { _count }
|
|
|
|
func increment() {
|
|
_count += 1
|
|
}
|
|
}
|
|
|
|
// swiftlint:enable discouraged_optional_boolean
|