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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2014-2022 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import Basics
import SPMTestSupport
import XCTest
import TSCclibc // for SPM_posix_spawn_file_actions_addchdir_np_supported
import class TSCBasic.InMemoryFileSystem
import struct TSCBasic.FileSystemError
class ZipArchiverTests: XCTestCase {
func testZipArchiverSuccess() async throws {
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let inputArchivePath = AbsolutePath(#file).parentDirectory.appending(components: "Inputs", "archive.zip")
try await archiver.extract(from: inputArchivePath, to: tmpdir)
let content = tmpdir.appending("file")
XCTAssert(localFileSystem.exists(content))
XCTAssertEqual((try? localFileSystem.readFileContents(content))?.cString, "Hello World!")
}
}
func testZipArchiverArchiveDoesntExist() async {
let fileSystem = InMemoryFileSystem()
let archiver = ZipArchiver(fileSystem: fileSystem)
let archive = AbsolutePath("/archive.zip")
await XCTAssertAsyncThrowsError(try await archiver.extract(from: archive, to: "/")) { error in
XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, archive))
}
}
func testZipArchiverDestinationDoesntExist() async throws {
let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.zip")
let archiver = ZipArchiver(fileSystem: fileSystem)
let destination = AbsolutePath("/destination")
await XCTAssertAsyncThrowsError(try await archiver.extract(from: "/archive.zip", to: destination)) { error in
XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
}
}
func testZipArchiverDestinationIsFile() async throws {
let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.zip", "/destination")
let archiver = ZipArchiver(fileSystem: fileSystem)
let destination = AbsolutePath("/destination")
await XCTAssertAsyncThrowsError(try await archiver.extract(from: "/archive.zip", to: destination)) { error in
XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
}
}
func testZipArchiverInvalidArchive() async throws {
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let inputArchivePath = AbsolutePath(#file).parentDirectory
.appending(components: "Inputs", "invalid_archive.zip")
await XCTAssertAsyncThrowsError(try await archiver.extract(from: inputArchivePath, to: tmpdir)) { error in
#if os(Windows)
XCTAssertMatch((error as? StringError)?.description, .contains("Unrecognized archive format"))
#else
XCTAssertMatch((error as? StringError)?.description, .contains("End-of-central-directory signature not found"))
#endif
}
}
}
func testValidation() async throws {
// valid
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let path = AbsolutePath(#file).parentDirectory
.appending(components: "Inputs", "archive.zip")
try await XCTAssertAsyncTrue(try await archiver.validate(path: path))
}
// invalid
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let path = AbsolutePath(#file).parentDirectory
.appending(components: "Inputs", "invalid_archive.zip")
try await XCTAssertAsyncFalse(try await archiver.validate(path: path))
}
// error
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let path = AbsolutePath.root.appending("does_not_exist.zip")
await XCTAssertAsyncThrowsError(try await archiver.validate(path: path)) { error in
XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, path))
}
}
}
func testCompress() async throws {
#if os(Linux)
guard SPM_posix_spawn_file_actions_addchdir_np_supported() else {
throw XCTSkip("working directory not supported on this platform")
}
#endif
try await testWithTemporaryDirectory { tmpdir in
let archiver = ZipArchiver(fileSystem: localFileSystem)
let rootDir = tmpdir.appending(component: UUID().uuidString)
try localFileSystem.createDirectory(rootDir)
try localFileSystem.writeFileContents(rootDir.appending("file1.txt"), string: "Hello World!")
let dir1 = rootDir.appending("dir1")
try localFileSystem.createDirectory(dir1)
try localFileSystem.writeFileContents(dir1.appending("file2.txt"), string: "Hello World 2!")
let dir2 = dir1.appending("dir2")
try localFileSystem.createDirectory(dir2)
try localFileSystem.writeFileContents(dir2.appending("file3.txt"), string: "Hello World 3!")
try localFileSystem.writeFileContents(dir2.appending("file4.txt"), string: "Hello World 4!")
let archivePath = tmpdir.appending(component: UUID().uuidString + ".zip")
try await archiver.compress(directory: rootDir, to: archivePath)
XCTAssertFileExists(archivePath)
let extractRootDir = tmpdir.appending(component: UUID().uuidString)
try localFileSystem.createDirectory(extractRootDir)
try await archiver.extract(from: archivePath, to: extractRootDir)
try localFileSystem.stripFirstLevel(of: extractRootDir)
XCTAssertFileExists(extractRootDir.appending("file1.txt"))
XCTAssertEqual(
try? localFileSystem.readFileContents(extractRootDir.appending("file1.txt")),
"Hello World!"
)
let extractedDir1 = extractRootDir.appending("dir1")
XCTAssertDirectoryExists(extractedDir1)
XCTAssertFileExists(extractedDir1.appending("file2.txt"))
XCTAssertEqual(
try? localFileSystem.readFileContents(extractedDir1.appending("file2.txt")),
"Hello World 2!"
)
let extractedDir2 = extractedDir1.appending("dir2")
XCTAssertDirectoryExists(extractedDir2)
XCTAssertFileExists(extractedDir2.appending("file3.txt"))
XCTAssertEqual(
try? localFileSystem.readFileContents(extractedDir2.appending("file3.txt")),
"Hello World 3!"
)
XCTAssertFileExists(extractedDir2.appending("file4.txt"))
XCTAssertEqual(
try? localFileSystem.readFileContents(extractedDir2.appending("file4.txt")),
"Hello World 4!"
)
}
}
}
|
