mirror of
https://github.com/sparkle-project/Sparkle
synced 2026-11-22 04:30:47 +00:00
1233 lines
73 KiB
Swift
1233 lines
73 KiB
Swift
//
|
|
// SUAppcastTest.swift
|
|
// Sparkle
|
|
//
|
|
// Created by Kornel on 17/02/2016.
|
|
// Copyright © 2016 Sparkle Project. All rights reserved.
|
|
//
|
|
|
|
import XCTest
|
|
|
|
class SUAppcastTest: XCTestCase {
|
|
|
|
func testParseAppcast() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
let hostVersion = "1.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
let items = appcast.items
|
|
|
|
XCTAssertEqual(4, items.count)
|
|
|
|
XCTAssertEqual("Version 2.0", items[0].title)
|
|
XCTAssertEqual("desc", items[0].itemDescription)
|
|
XCTAssertEqual("plain-text", items[0].itemDescriptionFormat)
|
|
XCTAssertEqual("Sat, 26 Jul 2014 15:20:11 +0000", items[0].dateString)
|
|
XCTAssertTrue(items[0].isCriticalUpdate)
|
|
XCTAssertEqual(items[0].versionString, "2.0")
|
|
|
|
// This is the best release matching our system version
|
|
XCTAssertEqual("Version 3.0", items[1].title)
|
|
XCTAssertEqual("desc3", items[1].itemDescription)
|
|
XCTAssertEqual("html", items[1].itemDescriptionFormat)
|
|
XCTAssertNil(items[1].dateString)
|
|
XCTAssertTrue(items[1].isCriticalUpdate)
|
|
XCTAssertEqual(items[1].phasedRolloutInterval, 86400)
|
|
XCTAssertEqual(items[1].versionString, "3.0")
|
|
|
|
XCTAssertEqual("Version 4.0", items[2].title)
|
|
XCTAssertNil(items[2].itemDescription)
|
|
XCTAssertEqual("Sat, 26 Jul 2014 15:20:13 +0000", items[2].dateString)
|
|
XCTAssertFalse(items[2].isCriticalUpdate)
|
|
|
|
XCTAssertEqual("Version 5.0", items[3].title)
|
|
XCTAssertNil(items[3].itemDescription)
|
|
XCTAssertNil(items[3].dateString)
|
|
XCTAssertFalse(items[3].isCriticalUpdate)
|
|
|
|
// Test best appcast item & a delta update item
|
|
let currentDate = Date()
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
let supportedAppcastItems = supportedAppcast.items
|
|
|
|
var deltaItem: SUAppcastItem?
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcastItems, getDeltaItem: &deltaItem, withHostVersion: "1.0", comparator: SUStandardVersionComparator())
|
|
|
|
XCTAssertEqual(bestAppcastItem, items[1])
|
|
XCTAssertEqual(deltaItem!.fileURL!.lastPathComponent, "3.0_from_1.0.patch")
|
|
XCTAssertEqual(deltaItem!.versionString, "3.0")
|
|
|
|
// Test latest delta update item available
|
|
var latestDeltaItem: SUAppcastItem?
|
|
SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcastItems, getDeltaItem: &latestDeltaItem, withHostVersion: "2.0", comparator: SUStandardVersionComparator())
|
|
|
|
XCTAssertEqual(latestDeltaItem!.fileURL!.lastPathComponent, "3.0_from_2.0.patch")
|
|
|
|
// Test a delta item that does not exist
|
|
var nonexistentDeltaItem: SUAppcastItem?
|
|
SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcastItems, getDeltaItem: &nonexistentDeltaItem, withHostVersion: "2.1", comparator: SUStandardVersionComparator())
|
|
|
|
XCTAssertNil(nonexistentDeltaItem)
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testChannelsAndMacOSReleases() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_channels", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
let hostVersion = "1.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
XCTAssertEqual(6, appcast.items.count)
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: ["beta", "nightly"])
|
|
XCTAssertEqual(4, filteredAppcast.items.count)
|
|
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
XCTAssertEqual("4.0", filteredAppcast.items[2].versionString)
|
|
XCTAssertEqual("5.0", filteredAppcast.items[3].versionString)
|
|
}
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: [])
|
|
XCTAssertEqual(2, filteredAppcast.items.count)
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
}
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: ["beta"])
|
|
XCTAssertEqual(3, filteredAppcast.items.count)
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
XCTAssertEqual("4.0", filteredAppcast.items[2].versionString)
|
|
}
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: ["nightly"])
|
|
XCTAssertEqual(3, filteredAppcast.items.count)
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
XCTAssertEqual("5.0", filteredAppcast.items[2].versionString)
|
|
}
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: ["madeup"])
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
XCTAssertEqual(2, filteredAppcast.items.count)
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testMinimumUpdateVersion() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_minimumUpdateVersion", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
let hostVersion = "1.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
XCTAssertEqual(4, appcast.items.count)
|
|
|
|
do {
|
|
let filteredAppcast = SUAppcastDriver.filterAppcast(appcast, forMacOSAndAllowedChannels: [])
|
|
XCTAssertEqual(3, filteredAppcast.items.count)
|
|
|
|
XCTAssertEqual("2.0", filteredAppcast.items[0].versionString)
|
|
XCTAssertEqual("3.0", filteredAppcast.items[1].versionString)
|
|
XCTAssertEqual("4.0", filteredAppcast.items[2].versionString)
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testCriticalUpdateVersion() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
|
|
// If critical update version is 1.5 and host version is 1.0, update should be marked critical
|
|
do {
|
|
let hostVersion = "1.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
XCTAssertTrue(appcast.items[0].isCriticalUpdate)
|
|
}
|
|
|
|
// If critical update version is 1.5 and host version is 1.5, update should not be marked critical
|
|
do {
|
|
let hostVersion = "1.5"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
XCTAssertFalse(appcast.items[0].isCriticalUpdate)
|
|
}
|
|
|
|
// If critical update version is 1.5 and host version is 1.6, update should not be marked critical
|
|
do {
|
|
let hostVersion = "1.6"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
XCTAssertFalse(appcast.items[0].isCriticalUpdate)
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testInformationalUpdateVersions() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_info_updates", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
|
|
// Test informational updates from version 1.0
|
|
do {
|
|
let hostVersion = "1.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertFalse(appcast.items[0].isInformationOnlyUpdate)
|
|
XCTAssertFalse(appcast.items[1].isInformationOnlyUpdate)
|
|
XCTAssertTrue(appcast.items[2].isInformationOnlyUpdate)
|
|
XCTAssertTrue(appcast.items[3].isInformationOnlyUpdate)
|
|
|
|
// Test delta updates inheriting informational only updates
|
|
do {
|
|
let deltaUpdate = appcast.items[2].deltaUpdates!["2.0"]!
|
|
XCTAssertTrue(deltaUpdate.isInformationOnlyUpdate)
|
|
}
|
|
}
|
|
|
|
// Test informational updates from version 2.3
|
|
do {
|
|
let hostVersion = "2.3"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertFalse(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 2.4
|
|
do {
|
|
let hostVersion = "2.4"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertTrue(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 2.5
|
|
do {
|
|
let hostVersion = "2.5"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertTrue(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 2.6
|
|
do {
|
|
let hostVersion = "2.6"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertFalse(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 0.5
|
|
do {
|
|
let hostVersion = "0.5"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertFalse(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 0.4
|
|
do {
|
|
let hostVersion = "0.4"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertTrue(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
// Test informational updates from version 0.0
|
|
do {
|
|
let hostVersion = "0.0"
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertTrue(appcast.items[1].isInformationOnlyUpdate)
|
|
}
|
|
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testMinimumAutoupdateVersion() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_minimumAutoupdateVersion", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator()
|
|
|
|
do {
|
|
// Test appcast without a filter
|
|
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertEqual(2, appcast.items.count)
|
|
}
|
|
|
|
let currentDate = Date()
|
|
// Because 3.0 has minimum autoupdate version of 2.0, we should be offered 2.0
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// We should be offered 3.0 if host version is 2.0
|
|
do {
|
|
let hostVersion = "2.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
|
|
// We should be offered 3.0 if host version is 2.5
|
|
do {
|
|
let hostVersion = "2.5"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
|
|
// Because 3.0 has minimum autoupdate version of 2.0, we would be be offered 2.0, but not if it has been skipped
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
// There should be no items if 2.0 is skipped from 1.0 and 3.0 fails minimum autoupdate version
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "2.0", majorVersion: nil, majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
|
|
// Try again but allowing minimum autoupdate version to fail
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "2.0", majorVersion: nil, majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip 3.0
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail skipping both 2.0 and 3.0
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "2.0", majorVersion: "3.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip "2.5"
|
|
// This should implicitly only skip 2.0
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "2.5", majorVersion: nil, majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
|
|
// This should not skip anything but require passing minimum autoupdate version
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "1.5", majorVersion: nil, majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// This should not skip anything but allow failing minimum autoupdate version
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "1.5", majorVersion: nil, majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
|
|
// This should not skip anything but require passing minimum autoupdate version
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "1.5", majorVersion: "1.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// This should not skip anything but allow failing minimum autoupdate version
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "1.5", majorVersion: "1.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "3.0")
|
|
}
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testMinimumAutoupdateVersionAdvancedSkipping() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_minimumAutoupdateVersionSkipping", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator()
|
|
|
|
do {
|
|
// Test appcast without a filter
|
|
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertEqual(5, appcast.items.count)
|
|
}
|
|
|
|
let currentDate = Date()
|
|
// Because 3.0 has minimum autoupdate version of 3.0, and 4.0 has minimum autoupdate version of 4.0, we should be offered 2.0
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "3.0"
|
|
// This should skip all 3.x versions, but not 4.x versions nor 2.x versions
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(3, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "4.1")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to pass and only skip major version "3.0"
|
|
// This should only return back the latest minor version available
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "4.0"
|
|
// This should skip all 3.x versions and 4.x versions but not 2.x versions
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "4.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testMinimumAutoupdateVersionIgnoringSkipping() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_minimumAutoupdateVersionSkipping2", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator()
|
|
|
|
let currentDate = Date()
|
|
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "3.0" with no subrelease version
|
|
// This should skip all 3.x versions except for 3.9 which ignores skipped upgrades below 3.5, but not 4.x versions nor 2.x versions
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(4, supportedAppcast.items.count)
|
|
|
|
XCTAssertEqual(supportedAppcast.items[0].versionString, "4.1")
|
|
XCTAssertEqual(supportedAppcast.items[1].versionString, "4.0")
|
|
XCTAssertEqual(supportedAppcast.items[2].versionString, "3.9")
|
|
XCTAssertEqual(supportedAppcast.items[3].versionString, "2.0")
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "4.1")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "3.0" with subrelease version 3.4
|
|
// This should skip all 3.x versions except for 3.9 which ignores skipped upgrades below 3.5, but not 4.x versions nor 2.x versions
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.4", majorSubreleaseVersion: nil)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(4, supportedAppcast.items.count)
|
|
|
|
XCTAssertEqual(supportedAppcast.items[0].versionString, "4.1")
|
|
XCTAssertEqual(supportedAppcast.items[1].versionString, "4.0")
|
|
XCTAssertEqual(supportedAppcast.items[2].versionString, "3.9")
|
|
XCTAssertEqual(supportedAppcast.items[3].versionString, "2.0")
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "4.1")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "3.0" with subrelease version 3.5
|
|
// This should skip all 3.x versions, but not 4.x versions nor 2.x versions
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: "3.5")
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(3, supportedAppcast.items.count)
|
|
|
|
XCTAssertEqual(supportedAppcast.items[0].versionString, "4.1")
|
|
XCTAssertEqual(supportedAppcast.items[1].versionString, "4.0")
|
|
XCTAssertEqual(supportedAppcast.items[2].versionString, "2.0")
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "4.1")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "3.0" with subrelease version 3.5.1
|
|
// This should skip all 3.x versions, but not 4.x versions nor 2.x versions
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "3.0", majorSubreleaseVersion: "3.5.1")
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(3, supportedAppcast.items.count)
|
|
|
|
XCTAssertEqual(supportedAppcast.items[0].versionString, "4.1")
|
|
XCTAssertEqual(supportedAppcast.items[1].versionString, "4.0")
|
|
XCTAssertEqual(supportedAppcast.items[2].versionString, "2.0")
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "4.1")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "4.0" with subrelease version 4.0
|
|
// This should skip all 3.x versions and 4.x versions, but not 2.x versions
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: nil, majorVersion: "4.0", majorSubreleaseVersion: "4.0")
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
|
|
XCTAssertEqual(supportedAppcast.items[0].versionString, "2.0")
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.0")
|
|
}
|
|
|
|
// Allow minimum autoupdate version to fail and only skip major version "4.0" with subrelease version 4.0, and skip minor version 2.1
|
|
// This should skip everything
|
|
do {
|
|
let skippedUpdate = SPUSkippedUpdate(minorVersion: "2.1", majorVersion: "4.0", majorSubreleaseVersion: "4.0")
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: skippedUpdate, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testARM64Requirement() throws {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_arm64HardwareRequirement", withExtension: "xml")!
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator()
|
|
|
|
do {
|
|
// Test appcast without a filter
|
|
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertEqual(6, appcast.items.count)
|
|
}
|
|
|
|
let currentDate = Date()
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: nil, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: false)
|
|
|
|
#if arch(x86_64)
|
|
// We're assuming this test is not run through Rosetta
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
XCTAssertEqual(bestAppcastItem.versionString, "2.1")
|
|
#else
|
|
if #available(macOS 27, *) {
|
|
XCTAssertEqual(6, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
XCTAssertEqual(bestAppcastItem.versionString, "6.0")
|
|
} else {
|
|
XCTAssertEqual(5, supportedAppcast.items.count)
|
|
|
|
let bestAppcastItem = SUAppcastDriver.bestItem(fromAppcastItems: supportedAppcast.items, getDeltaItem: nil, withHostVersion: hostVersion, comparator: versionComparator)
|
|
XCTAssertEqual(bestAppcastItem.versionString, "5.0")
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPhasedGroupRollouts() {
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_phasedRollout", withExtension: "xml")!
|
|
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.dateFormat = "E, dd MMM yyyy HH:mm:ss Z"
|
|
dateFormatter.locale = Locale(identifier: "en_US")
|
|
|
|
do {
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let versionComparator = SUStandardVersionComparator()
|
|
|
|
// Because 3.0 has minimum autoupdate version of 2.0, we should be offered 2.0
|
|
do {
|
|
let hostVersion = "1.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
do {
|
|
// Test no group
|
|
let group: NSNumber? = nil
|
|
let currentDate = Date()
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
XCTAssertEqual("2.0", supportedAppcast.items[0].versionString)
|
|
}
|
|
|
|
do {
|
|
// Test 0 group with current date (way ahead of pubDate)
|
|
let group: NSNumber? = nil
|
|
let currentDate = Date()
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test 6th group with current date (way ahead of pubDate)
|
|
let group = 6 as NSNumber
|
|
let currentDate = Date()
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
let currentDate = dateFormatter.date(from: "Wed, 23 Jul 2014 15:20:11 +0000")!
|
|
|
|
do {
|
|
// Test group 0 with current date 3 days before rollout
|
|
// No update should be found
|
|
let group = 0 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test group 6 with current date 3 days before rollout
|
|
// No update should be found still
|
|
let group = 6 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
}
|
|
|
|
do {
|
|
let currentDate = dateFormatter.date(from: "Mon, 28 Jul 2014 15:20:11 +0000")!
|
|
|
|
do {
|
|
// Test group 0 with current date 2 days after rollout
|
|
let group = 0 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test group 1 with current date 3 days after rollout
|
|
let group = 1 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test group 2 with current date 3 days after rollout
|
|
let group = 2 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test group 3 with current date 3 days after rollout
|
|
let group = 3 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
|
|
do {
|
|
// Test group 6 with current date 3 days after rollout
|
|
let group = 6 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(0, supportedAppcast.items.count)
|
|
}
|
|
}
|
|
|
|
// Test critical updates which ignore phased rollouts
|
|
do {
|
|
let hostVersion = "2.0"
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: hostVersion, applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
do {
|
|
// Test no group
|
|
let group: NSNumber? = nil
|
|
let currentDate = Date()
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(2, supportedAppcast.items.count)
|
|
XCTAssertEqual("3.0", supportedAppcast.items[0].versionString)
|
|
}
|
|
|
|
do {
|
|
let currentDate = dateFormatter.date(from: "Wed, 23 Jul 2014 15:20:11 +0000")!
|
|
|
|
do {
|
|
// Test group 0 with current date 3 days before rollout
|
|
let group = 0 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
XCTAssertEqual("3.0", supportedAppcast.items[0].versionString)
|
|
}
|
|
}
|
|
|
|
do {
|
|
let currentDate = dateFormatter.date(from: "Mon, 28 Jul 2014 15:20:11 +0000")!
|
|
|
|
do {
|
|
// Test group 6 with current date 3 days after rollout
|
|
let group = 6 as NSNumber
|
|
|
|
let supportedAppcast = SUAppcastDriver.filterSupportedAppcast(appcast, phasedUpdateGroup: group, skippedUpdate: nil, currentDate: currentDate, hostVersion: hostVersion, versionComparator: versionComparator, testMinimumSystemRequirements: true, testMinimumAutoupdateVersion: true)
|
|
|
|
XCTAssertEqual(1, supportedAppcast.items.count)
|
|
XCTAssertEqual("3.0", supportedAppcast.items[0].versionString)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testParseAppcastWithLocalizedReleaseNotes() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "testlocalizedreleasenotesappcast",
|
|
ofType: "xml")!
|
|
let testFileUrl = URL(fileURLWithPath: testFile)
|
|
XCTAssertNotNil(testFileUrl)
|
|
|
|
let preferredLanguage = Bundle.preferredLocalizations(from: ["en", "es"])[0]
|
|
|
|
NSLog("Using preferred locale %@", preferredLanguage)
|
|
|
|
let expectedReleaseNotesLink = (preferredLanguage == "es") ? "https://sparkle-project.org/notes.es.html" : "https://sparkle-project.org/notes.en.html"
|
|
|
|
do {
|
|
let testFileData = try Data(contentsOf: testFileUrl)
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let fullAppcast = try SUAppcast(xmlData: testFileData, relativeTo: testFileUrl, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
do {
|
|
let appcast = SUAppcastDriver.filterAppcast(fullAppcast, forMacOSAndAllowedChannels: ["english-later"])
|
|
let items = appcast.items
|
|
XCTAssertEqual(items.count, 1)
|
|
XCTAssertEqual(items[0].versionString, "6.0")
|
|
XCTAssertEqual(expectedReleaseNotesLink, items[0].releaseNotesURL!.absoluteString)
|
|
}
|
|
|
|
do {
|
|
let appcast = SUAppcastDriver.filterAppcast(fullAppcast, forMacOSAndAllowedChannels: ["english-first"])
|
|
let items = appcast.items
|
|
XCTAssertEqual(items.count, 1)
|
|
XCTAssertEqual(items[0].versionString, "6.1")
|
|
XCTAssertEqual(expectedReleaseNotesLink, items[0].releaseNotesURL!.absoluteString)
|
|
}
|
|
|
|
do {
|
|
let appcast = SUAppcastDriver.filterAppcast(fullAppcast, forMacOSAndAllowedChannels: ["english-first-implicit"])
|
|
let items = appcast.items
|
|
XCTAssertEqual(items.count, 1)
|
|
XCTAssertEqual(items[0].versionString, "6.2")
|
|
XCTAssertEqual(expectedReleaseNotesLink, items[0].releaseNotesURL!.absoluteString)
|
|
}
|
|
|
|
do {
|
|
let appcast = SUAppcastDriver.filterAppcast(fullAppcast, forMacOSAndAllowedChannels: ["english-later-implicit"])
|
|
let items = appcast.items
|
|
XCTAssertEqual(items.count, 1)
|
|
XCTAssertEqual(items[0].versionString, "6.3")
|
|
XCTAssertEqual(expectedReleaseNotesLink, items[0].releaseNotesURL!.absoluteString)
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testNamespaces() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "testnamespaces", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
let items = appcast.items
|
|
|
|
XCTAssertEqual(4, items.count)
|
|
|
|
XCTAssertEqual("Version 2.0", items[1].title)
|
|
XCTAssertEqual("desc", items[1].itemDescription)
|
|
XCTAssertNotNil(items[0].releaseNotesURL)
|
|
XCTAssertEqual("https://sparkle-project.org/#works", items[0].releaseNotesURL!.absoluteString)
|
|
|
|
// Child elements of <sparkle:informationalUpdate> and <sparkle:tags> must be
|
|
// resolved through the namespace URI too, not through their qualified name
|
|
XCTAssertFalse(items[2].isInformationOnlyUpdate)
|
|
XCTAssertTrue(items[3].isCriticalUpdate)
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testLinks() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-links", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let baseURL: URL? = nil
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: baseURL, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
let items = appcast.items
|
|
|
|
XCTAssertEqual(3, items.count)
|
|
|
|
// Test https
|
|
XCTAssertEqual("https://sparkle-project.org/notes/relnote-3.0.txt", items[0].releaseNotesURL?.absoluteString)
|
|
XCTAssertEqual(1234, items[0].releaseNotesContentLength)
|
|
XCTAssertEqual("https://sparkle-project.org/fullnotes.txt", items[0].fullReleaseNotesURL?.absoluteString)
|
|
XCTAssertEqual("https://sparkle-project.org", items[0].infoURL?.absoluteString)
|
|
XCTAssertEqual("https://sparkle-project.org/release-3.0.zip", items[0].fileURL?.absoluteString)
|
|
|
|
// Test http
|
|
XCTAssertEqual("http://sparkle-project.org/notes/relnote-2.0.txt", items[1].releaseNotesURL?.absoluteString)
|
|
XCTAssertEqual(0, items[1].releaseNotesContentLength)
|
|
XCTAssertEqual("http://sparkle-project.org/fullnotes.txt", items[1].fullReleaseNotesURL?.absoluteString)
|
|
XCTAssertEqual("http://sparkle-project.org", items[1].infoURL?.absoluteString)
|
|
XCTAssertEqual("http://sparkle-project.org/release-2.0.zip", items[1].fileURL?.absoluteString)
|
|
|
|
// Test bad file URLs
|
|
XCTAssertEqual(nil, items[2].releaseNotesURL?.absoluteString)
|
|
XCTAssertEqual(nil, items[2].fullReleaseNotesURL?.absoluteString)
|
|
XCTAssertEqual(nil, items[2].infoURL?.absoluteString)
|
|
XCTAssertEqual("https://sparkle-project.org/release-1.0.zip", items[2].fileURL?.absoluteString)
|
|
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testRelativeURLs() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-relative-urls", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let baseURL = URL(string: "https://fake.sparkle-project.org/updates/index.xml")!
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: baseURL, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
let items = appcast.items
|
|
|
|
XCTAssertEqual(4, items.count)
|
|
|
|
XCTAssertEqual("https://fake.sparkle-project.org/updates/release-3.0.zip", items[0].fileURL?.absoluteString)
|
|
XCTAssertEqual("https://fake.sparkle-project.org/updates/notes/relnote-3.0.txt", items[0].releaseNotesURL?.absoluteString)
|
|
|
|
XCTAssertEqual(2, items[0].deltaUpdates!.count)
|
|
|
|
XCTAssertEqual("https://fake.sparkle-project.org/updates/3.0_from_2.0.delta", items[0].deltaUpdates!["2.0"]!.fileURL?.absoluteString)
|
|
XCTAssertEqual("https://fake.sparkle-project.org/updates/3.0_from_1.0.delta", items[0].deltaUpdates!["1.0"]!.fileURL?.absoluteString)
|
|
|
|
XCTAssertEqual("https://fake.sparkle-project.org/info/info-2.0.txt", items[1].infoURL?.absoluteString)
|
|
|
|
XCTAssertEqual("https://fake.sparkle-project.org/updates/notes/fullnotes.txt", items[2].fullReleaseNotesURL?.absoluteString)
|
|
|
|
// If a different base URL is in the feed, we should respect the base URL in the feed
|
|
XCTAssertEqual("https://sparkle-project.org/releasenotes.html", items[3].fullReleaseNotesURL?.absoluteString)
|
|
|
|
} catch let err as NSError {
|
|
NSLog("%@", err)
|
|
XCTFail(err.localizedDescription)
|
|
}
|
|
}
|
|
|
|
func testDangerousLink() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-dangerous-link", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let baseURL: URL? = nil
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let _ = try SUAppcast(xmlData: testData as Data, relativeTo: baseURL, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTFail("Appcast creation should fail when encountering dangerous link")
|
|
} catch let err as NSError {
|
|
NSLog("Expected error: %@", err)
|
|
XCTAssertNotNil(err)
|
|
}
|
|
}
|
|
|
|
func testDangerousLinkWithSucceededSigningValidation() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-dangerous-link", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let baseURL: URL? = nil
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let _ = try SUAppcast(xmlData: testData as Data, relativeTo: baseURL, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTFail("Appcast creation should fail when encountering dangerous link")
|
|
} catch let err as NSError {
|
|
NSLog("Expected error: %@", err)
|
|
XCTAssertNotNil(err)
|
|
}
|
|
}
|
|
|
|
func testDangerousLinkWithFailedSigningValidation() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-dangerous-link", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let baseURL: URL? = nil
|
|
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: baseURL, stateResolver: stateResolver, signingValidationStatus: .failed)
|
|
|
|
// Links and info only and critical updates should be stripped/removed appropriately
|
|
|
|
XCTAssertEqual(appcast.items.count, 2)
|
|
XCTAssertEqual(appcast.signingValidationStatus, .failed)
|
|
|
|
for (appcastItemIndex, appcastItem) in appcast.items.enumerated() {
|
|
XCTAssertNil(appcastItem.infoURL)
|
|
XCTAssertNil(appcastItem.releaseNotesURL)
|
|
XCTAssertNil(appcastItem.fullReleaseNotesURL)
|
|
XCTAssertFalse(appcastItem.isCriticalUpdate)
|
|
|
|
if appcastItemIndex == 0 {
|
|
XCTAssertEqual(appcastItem.versionString, "3.0 (Visit abc.")
|
|
} else if appcastItemIndex == 1 {
|
|
XCTAssertEqual(appcastItem.displayVersionString, "2.0 (Visit abc.")
|
|
}
|
|
}
|
|
} catch let err as NSError {
|
|
NSLog("Expected error: %@", err)
|
|
XCTFail("Appcast creation should have passed when encountering dangerous link of one item")
|
|
}
|
|
}
|
|
|
|
func testPackageInstallAllowedWithSkippedSigningValidation() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-package-update", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .skipped)
|
|
|
|
XCTAssertEqual(appcast.items.count, 2)
|
|
XCTAssertEqual(appcast.items[0].installationType, SPUInstallationTypeGuidedPackage)
|
|
XCTAssertEqual(appcast.items[1].installationType, SPUInstallationTypeApplication)
|
|
} catch let err as NSError {
|
|
NSLog("Unexpected error: %@", err)
|
|
XCTFail("Appcast creation should have passed when signing validation is skipped")
|
|
}
|
|
}
|
|
|
|
func testPackageInstallRejectedWithFailedSigningValidation() {
|
|
let testFile = Bundle(for: SUAppcastTest.self).path(forResource: "test-package-update", ofType: "xml")!
|
|
let testData = NSData(contentsOfFile: testFile)!
|
|
|
|
do {
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: SUStandardVersionComparator.default, standardVersionComparator: SUStandardVersionComparator.default)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData as Data, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .failed)
|
|
|
|
// The package-based item should be rejected because signing validation on the feed failed;
|
|
// only the application-based item should remain
|
|
XCTAssertEqual(appcast.items.count, 1)
|
|
XCTAssertEqual(appcast.items[0].installationType, SPUInstallationTypeApplication)
|
|
XCTAssertEqual(appcast.items[0].versionString, "1.0")
|
|
} catch let err as NSError {
|
|
NSLog("Unexpected error: %@", err)
|
|
XCTFail("Appcast creation should have passed, dropping only the rejected package item")
|
|
}
|
|
}
|
|
|
|
func testParseAppcastBundleIdentifiers() throws {
|
|
let versionComparator = SUStandardVersionComparator.default
|
|
let stateResolver = SPUAppcastItemStateResolver(hostVersion: "1.0", applicationVersionComparator: versionComparator, standardVersionComparator: versionComparator)
|
|
|
|
let testURL = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast_bundleIdentifiers", withExtension: "xml")!
|
|
let testData = try Data(contentsOf: testURL)
|
|
|
|
let appcast = try SUAppcast(xmlData: testData, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .succeeded)
|
|
XCTAssertEqual(appcast.bundleIdentifiers, ["com.example.first", "com.example.second"])
|
|
XCTAssertEqual(appcast.items.count, 1)
|
|
|
|
let filteredAppcast = appcast.copy(byFilteringItems: { _ in false })
|
|
XCTAssertEqual(filteredAppcast.bundleIdentifiers, ["com.example.first", "com.example.second"])
|
|
|
|
let testURLWithoutBundleIdentifiers = Bundle(for: SUAppcastTest.self).url(forResource: "testappcast", withExtension: "xml")!
|
|
let testDataWithoutBundleIdentifiers = try Data(contentsOf: testURLWithoutBundleIdentifiers)
|
|
|
|
let appcastWithoutBundleIdentifiers = try SUAppcast(xmlData: testDataWithoutBundleIdentifiers, relativeTo: nil, stateResolver: stateResolver, signingValidationStatus: .succeeded)
|
|
XCTAssertEqual(appcastWithoutBundleIdentifiers.bundleIdentifiers, [])
|
|
}
|
|
}
|