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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2014-2017 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 Dispatch
import PackageGraph
import PackageModel
import SourceControl
import XCTest
import struct TSCUtility.Version
public class MockPackageContainer: CustomPackageContainer {
public typealias Constraint = PackageContainerConstraint
public typealias Dependency = (container: PackageReference, requirement: PackageRequirement)
public let package: PackageReference
let dependencies: [String: [Dependency]]
let filteredMode: Bool
let filteredDependencies: [ProductFilter: [Dependency]]
let fileSystem: FileSystem?
let customRetrievalPath: AbsolutePath?
public var unversionedDeps: [MockPackageContainer.Constraint] = []
/// Contains the versions for which the dependencies were requested by resolver using getDependencies().
public var requestedVersions: Set<Version> = []
public let _versions: [Version]
public func toolsVersionsAppropriateVersionsDescending() throws -> [Version] {
return try self.versionsDescending()
}
public func versionsAscending() throws -> [Version] {
return _versions
}
public func getDependencies(at version: Version, productFilter: ProductFilter) -> [MockPackageContainer.Constraint] {
requestedVersions.insert(version)
return getDependencies(at: version.description, productFilter: productFilter)
}
public func getDependencies(at revision: String, productFilter: ProductFilter) -> [MockPackageContainer.Constraint] {
let dependencies: [Dependency]
if filteredMode {
dependencies = filteredDependencies[productFilter]!
} else {
dependencies = self.dependencies[revision]!
}
return dependencies.map { value in
let (package, requirement) = value
return MockPackageContainer.Constraint(package: package, requirement: requirement, products: productFilter)
}
}
public func getUnversionedDependencies(productFilter: ProductFilter) -> [MockPackageContainer.Constraint] {
return unversionedDeps
}
public func loadPackageReference(at boundVersion: BoundVersion) throws -> PackageReference {
return self.package
}
public func isToolsVersionCompatible(at version: Version) -> Bool {
return true
}
public func toolsVersion(for version: Version) throws -> ToolsVersion {
return ToolsVersion.current
}
public var isRemoteContainer: Bool? {
return true
}
public func retrieve(at version: Version, progressHandler: ((Int64, Int64?) -> Void)?, observabilityScope: ObservabilityScope) throws -> AbsolutePath {
if let customRetrievalPath {
return customRetrievalPath
} else {
throw StringError("no path configured for mock package container")
}
}
public func getFileSystem() throws -> FileSystem? {
return fileSystem
}
public convenience init(
name: String,
dependenciesByVersion: [Version: [(container: String, versionRequirement: VersionSetSpecifier)]]
) throws {
var dependencies: [String: [Dependency]] = [:]
for (version, deps) in dependenciesByVersion {
dependencies[version.description] = try deps.map {
let path = try AbsolutePath(validating: "/\($0.container)")
let ref = PackageReference.localSourceControl(identity: .init(path: path), path: path)
return (ref, .versionSet($0.versionRequirement))
}
}
let path = try AbsolutePath(validating: "/\(name)")
let ref = PackageReference.localSourceControl(identity: .init(path: path), path: path)
self.init(package: ref, dependencies: dependencies)
}
public init(
package: PackageReference,
dependencies: [String: [Dependency]] = [:],
fileSystem: FileSystem? = nil,
customRetrievalPath: AbsolutePath? = nil
) {
self.package = package
self._versions = dependencies.keys.compactMap(Version.init(_:)).sorted()
self.dependencies = dependencies
self.filteredMode = false
self.filteredDependencies = [:]
self.fileSystem = fileSystem
self.customRetrievalPath = customRetrievalPath
}
public init(
name: String,
dependenciesByProductFilter: [ProductFilter: [(container: String, versionRequirement: VersionSetSpecifier)]]
) throws {
var dependencies: [ProductFilter: [Dependency]] = [:]
for (filter, deps) in dependenciesByProductFilter {
dependencies[filter] = try deps.map {
let path = try AbsolutePath(validating: "/\($0.container)")
let ref = PackageReference.localSourceControl(identity: .init(path: path), path: path)
return (ref, .versionSet($0.versionRequirement))
}
}
let path = try AbsolutePath(validating: "/\(name)")
let ref = PackageReference.localSourceControl(identity: .init(path: path), path: path)
self.package = ref
self._versions = [Version(1, 0, 0)]
self.dependencies = [:]
self.filteredMode = true
self.filteredDependencies = dependencies
self.fileSystem = nil
self.customRetrievalPath = nil
}
}
public struct MockPackageContainerProvider: PackageContainerProvider {
public let containers: [MockPackageContainer]
public let containersByIdentifier: [PackageReference: MockPackageContainer]
public init(containers: [MockPackageContainer]) {
self.containers = containers
self.containersByIdentifier = Dictionary(uniqueKeysWithValues: containers.map { ($0.package, $0) })
}
public func getContainer(
for package: PackageReference,
updateStrategy: ContainerUpdateStrategy,
observabilityScope: ObservabilityScope,
on queue: DispatchQueue,
completion: @escaping (Result<PackageContainer, Swift.Error>
) -> Void
) {
queue.async {
completion(self.containersByIdentifier[package].map { .success($0) } ??
.failure(StringError("unknown module \(package)")))
}
}
}
|
