1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/*
This source file is part of the Swift.org open source project
Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See http://swift.org/LICENSE.txt for license information
See http://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
import XCTest
import TSCBasic
import TSCUtility
import TSCTestSupport
// FIXME: deprecate 2/2022, remove once clients transitioned
@available(*, deprecated, message: "moved to SwiftPM")
class ArchiverTests: XCTestCase {
// MARK: - ZipArchiver Tests
func testZipArchiverSuccess() throws {
try testWithTemporaryDirectory { tmpdir in
let expectation = XCTestExpectation(description: "success")
let archiver = ZipArchiver()
let inputArchivePath = AbsolutePath(path: #file).parentDirectory.appending(components: "Inputs", "archive.zip")
archiver.extract(from: inputArchivePath, to: tmpdir, completion: { result in
XCTAssertResultSuccess(result) { _ in
let content = tmpdir.appending(component: "file")
XCTAssert(localFileSystem.exists(content))
XCTAssertEqual((try? localFileSystem.readFileContents(content))?.cString, "Hello World!")
}
expectation.fulfill()
})
wait(for: [expectation], timeout: 1.0)
}
}
func testZipArchiverArchiveDoesntExist() {
let expectation = XCTestExpectation(description: "failure")
let fileSystem = InMemoryFileSystem()
let archiver = ZipArchiver(fileSystem: fileSystem)
let archive = AbsolutePath(path: "/archive.zip")
archiver.extract(from: archive, to: AbsolutePath(path: "/"), completion: { result in
XCTAssertResultFailure(result, equals: FileSystemError(.noEntry, archive))
expectation.fulfill()
})
wait(for: [expectation], timeout: 1.0)
}
func testZipArchiverDestinationDoesntExist() {
let expectation = XCTestExpectation(description: "failure")
let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.zip")
let archiver = ZipArchiver(fileSystem: fileSystem)
let destination = AbsolutePath(path: "/destination")
archiver.extract(from: AbsolutePath(path: "/archive.zip"), to: destination, completion: { result in
XCTAssertResultFailure(result, equals: FileSystemError(.notDirectory, destination))
expectation.fulfill()
})
wait(for: [expectation], timeout: 1.0)
}
func testZipArchiverDestinationIsFile() {
let expectation = XCTestExpectation(description: "failure")
let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.zip", "/destination")
let archiver = ZipArchiver(fileSystem: fileSystem)
let destination = AbsolutePath(path: "/destination")
archiver.extract(from: AbsolutePath(path: "/archive.zip"), to: destination, completion: { result in
XCTAssertResultFailure(result, equals: FileSystemError(.notDirectory, destination))
expectation.fulfill()
})
wait(for: [expectation], timeout: 1.0)
}
func testZipArchiverInvalidArchive() throws {
try testWithTemporaryDirectory { tmpdir in
let expectation = XCTestExpectation(description: "failure")
let archiver = ZipArchiver()
let inputArchivePath = AbsolutePath(path: #file).parentDirectory
.appending(components: "Inputs", "invalid_archive.zip")
archiver.extract(from: inputArchivePath, to: tmpdir, completion: { result in
XCTAssertResultFailure(result) { error in
guard let stringError = error as? StringError else {
XCTFail("unexpected error: \(error)")
return
}
XCTAssertMatch(stringError.description, .contains("End-of-central-directory signature not found"))
}
expectation.fulfill()
})
wait(for: [expectation], timeout: 1.0)
}
}
}
private struct DummyError: Error, Equatable {
}
private typealias Extraction = (AbsolutePath, AbsolutePath, (Result<Void, Error>) -> Void) -> Void
@available(*, deprecated)
private struct MockArchiver: Archiver {
let supportedExtensions: Set<String>
private let extract: Extraction
init(supportedExtensions: Set<String>, extract: @escaping Extraction) {
self.supportedExtensions = supportedExtensions
self.extract = extract
}
func extract(
from archivePath: AbsolutePath,
to destinationPath: AbsolutePath,
completion: @escaping (Result<Void, Error>) -> Void
) {
self.extract(archivePath, destinationPath, completion)
}
}
|
