Update to use generic Test.Attachment

Author: grynspan

Sources/Overlays/_Testing_Foundation/Attachments/Data+Test.Attachable.swift

@@ -14,7 +14,7 @@ public import Foundation
 
 @_spi(Experimental)
 extension Data: Test.Attachable {
-  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment<Self>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
     try withUnsafeBytes(body)
   }
 }

Sources/Overlays/_Testing_Foundation/Attachments/EncodingFormat.swift

@@ -41,7 +41,7 @@ enum EncodingFormat {
   ///   - attachment: The attachment that will be encoded.
   ///
   /// - Throws: If the attachment's content type or media type is unsupported.
-  init(for attachment: borrowing Test.Attachment) throws {
+  init(for attachment: borrowing Test.Attachment<some Test.Attachable>) throws {
     let ext = (attachment.preferredName as NSString).pathExtension
 
 #if SWT_TARGET_OS_APPLE && canImport(UniformTypeIdentifiers)

Sources/Overlays/_Testing_Foundation/Attachments/Test.Attachable+Encodable&NSSecureCoding.swift

@@ -15,11 +15,8 @@ public import Foundation
 @_spi(Experimental)
 extension Test.Attachable where Self: Encodable & NSSecureCoding {
   @_documentation(visibility: private)
-  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
-    func open(_ value: some Encodable & Test.Attachable, for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
-      return try value.withUnsafeBufferPointer(for: attachment, body)
-    }
-    return try open(self, for: attachment, body)
+  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment<Self>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+    try _Testing_Foundation.withUnsafeBufferPointer(encoding: self, for: attachment, body)
   }
 }
 #endif

Sources/Overlays/_Testing_Foundation/Attachments/Test.Attachable+Encodable.swift

@@ -12,6 +12,43 @@
 @_spi(Experimental) public import Testing
 private import Foundation
 
+/// A common implementation of ``withUnsafeBufferPointer(for:_:)`` that is
+/// used when a type conforms to `Encodable`, whether or not it also conforms
+/// to `NSSecureCoding`.
+///
+/// - Parameters:
+///   - attachment: The attachment that is requesting a buffer (that is, the
+///     attachment containing this instance.)
+///   - body: A function to call. A temporary buffer containing a data
+///     representation of this instance is passed to it.
+///
+/// - Returns: Whatever is returned by `body`.
+///
+/// - Throws: Whatever is thrown by `body`, or any error that prevented the
+///   creation of the buffer.
+func withUnsafeBufferPointer<E, R>(encoding attachableValue: borrowing E, for attachment: borrowing Test.Attachment<E>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R where E: Test.Attachable & Encodable {
+  let format = try EncodingFormat(for: attachment)
+
+  let data: Data
+  switch format {
+  case let .propertyListFormat(propertyListFormat):
+    let plistEncoder = PropertyListEncoder()
+    plistEncoder.outputFormat = propertyListFormat
+    data = try plistEncoder.encode(attachableValue)
+  case .default:
+    // The default format is JSON.
+    fallthrough
+  case .json:
+    // We cannot use our own JSON encoding wrapper here because that would
+    // require it be exported with (at least) package visibility which would
+    // create a visible external dependency on Foundation in the main testing
+    // library target.
+    data = try JSONEncoder().encode(attachableValue)
+  }
+
+  return try data.withUnsafeBytes(body)
+}
+
 // Implement the protocol requirements generically for any encodable value by
 // encoding to JSON. This lets developers provide trivial conformance to the
 // protocol for types that already support Codable.
@@ -53,27 +90,8 @@ extension Test.Attachable where Self: Encodable {
   ///   some other path extension, that path extension must represent a type
   ///   that conforms to [`UTType.propertyList`](https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/propertylist)
   ///   or to [`UTType.json`](https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/json).
-  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
-    let format = try EncodingFormat(for: attachment)
-
-    let data: Data
-    switch format {
-    case let .propertyListFormat(propertyListFormat):
-      let plistEncoder = PropertyListEncoder()
-      plistEncoder.outputFormat = propertyListFormat
-      data = try plistEncoder.encode(self)
-    case .default:
-      // The default format is JSON.
-      fallthrough
-    case .json:
-      // We cannot use our own JSON encoding wrapper here because that would
-      // require it be exported with (at least) package visibility which would
-      // create a visible external dependency on Foundation in the main testing
-      // library target.
-      data = try JSONEncoder().encode(self)
-    }
-
-    return try data.withUnsafeBytes(body)
+  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment<Self>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+    try _Testing_Foundation.withUnsafeBufferPointer(encoding: self, for: attachment, body)
   }
 }
 #endif

Sources/Overlays/_Testing_Foundation/Attachments/Test.Attachable+NSSecureCoding.swift

@@ -50,7 +50,7 @@ extension Test.Attachable where Self: NSSecureCoding {
   /// - Note: On Apple platforms, if the attachment's preferred name includes
   ///   some other path extension, that path extension must represent a type
   ///   that conforms to [`UTType.propertyList`](https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/propertylist).
-  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+  public func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment<Self>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
     let format = try EncodingFormat(for: attachment)
 
     var data = try NSKeyedArchiver.archivedData(withRootObject: self, requiringSecureCoding: true)

Sources/Overlays/_Testing_Foundation/Attachments/Test.Attachment+URL.swift

@@ -42,7 +42,7 @@ extension UTType {
 #endif
 
 @_spi(Experimental)
-extension Test.Attachment {
+extension Test.Attachment where AttachableValue == FileAttachment {
   /// Initialize an instance of this type with the contents of the given URL.
   ///
   /// - Parameters:
@@ -55,8 +55,7 @@ extension Test.Attachment {
   /// - Throws: Any error that occurs attempting to read from `url`.
   public init(
     contentsOf url: URL,
-    named preferredName: String? = nil,
-    sourceLocation: SourceLocation = #_sourceLocation
+    named preferredName: String? = nil
   ) async throws {
     guard url.isFileURL else {
       // TODO: network URLs?
@@ -88,30 +87,39 @@ extension Test.Attachment {
         return (preferredName as NSString).appendingPathExtension("tgz") ?? preferredName
       }()
 
-      let attachableValue = try await _DirectoryContentAttachableProxy(contentsOfDirectoryAt: url)
-      self.init(attachableValue, named: preferredName, sourceLocation: sourceLocation)
+      try await self.init(FileAttachment(compressedContentsOfDirectoryAt: url), named: preferredName)
     } else {
       // Load the file.
-      let attachableValue = try Data(contentsOf: url, options: [.mappedIfSafe])
-      self.init(attachableValue, named: preferredName, sourceLocation: sourceLocation)
+      try self.init(FileAttachment(contentsOfFileAt: url), named: preferredName)
     }
   }
 }
 
-// MARK: - Attaching directories
+// MARK: - Attaching files and directories
 
-/// A type representing the content of a directory as an attachable value.
-private struct _DirectoryContentAttachableProxy: Test.Attachable {
-  /// The URL of the directory.
-  ///
-  /// The contents of this directory may change after this instance is
-  /// initialized. Such changes are not tracked.
-  var url: URL
+/// A type representing a file system object that has been added to an
+/// attachment.
+@_spi(Experimental)
+public struct FileAttachment: Test.Attachable, Sendable {
+  /// The file URL where the represented file system object is located.
+  public private(set) var url: URL
 
-  /// The archived contents of the directory.
-  private let _directoryContent: Data
+  /// The contents of the file or directory at `url`.
+  private var _data: Data
+
+  /// Initialize an instance of this type by reading the contents of a file.
+  ///
+  /// - Parameters:
+  ///   - fileURL: A URL referring to the file to attach.
+  ///
+  /// - Throws: Any error encountered trying to read the file at `fileURL`.
+  init(contentsOfFileAt fileURL: URL) throws {
+    url = fileURL
+    _data = try Data(contentsOf: url, options: [.mappedIfSafe])
+  }
 
-  /// Initialize an instance of this type.
+  /// Initialize an instance of this type by compressing the contents of a
+  /// directory.
   ///
   /// - Parameters:
   ///   - directoryURL: A URL referring to the directory to attach.
@@ -122,9 +130,7 @@ private struct _DirectoryContentAttachableProxy: Test.Attachable {
   /// This initializer asynchronously compresses the contents of `directoryURL`
   /// into an archive (currently of `.tgz` format, although this is subject to
   /// change) and stores a mapped copy of that archive.
-  init(contentsOfDirectoryAt directoryURL: URL) async throws {
-    url = directoryURL
-
+  init(compressedContentsOfDirectoryAt directoryURL: URL) async throws {
     let temporaryName = "\(UUID().uuidString).tgz"
     let temporaryURL = FileManager.default.temporaryDirectory.appendingPathComponent(temporaryName)
 
@@ -134,7 +140,7 @@ private struct _DirectoryContentAttachableProxy: Test.Attachable {
 #else
     let tarPath = "/usr/bin/tar"
 #endif
-    let sourcePath = url.fileSystemPath
+    let sourcePath = directoryURL.fileSystemPath
     let destinationPath = temporaryURL.fileSystemPath
     defer {
       remove(destinationPath)
@@ -161,14 +167,20 @@ private struct _DirectoryContentAttachableProxy: Test.Attachable {
         continuation.resume(throwing: error)
       }
     }
-    _directoryContent = try Data(contentsOf: temporaryURL, options: [.mappedIfSafe])
+
+    url = directoryURL
+    _data = try Data(contentsOf: temporaryURL, options: [.mappedIfSafe])
 #else
     throw CocoaError(.featureUnsupported, userInfo: [NSLocalizedDescriptionKey: "This platform does not support attaching directories to tests."])
 #endif
   }
 
-  func withUnsafeBufferPointer<R>(for attachment: borrowing Test.Attachment, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
-    try _directoryContent.withUnsafeBytes(body)
+  public var estimatedAttachmentByteCount: Int? {
+    _data.count
+  }
+
+  public func withUnsafeBufferPointer<R>(for attachment: borrowing Testing.Test.Attachment<FileAttachment>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+    try _data.withUnsafeBytes(body)
   }
 }
 #endif

Tests/TestingTests/AttachmentTests.swift

@@ -233,13 +233,13 @@ struct AttachmentTests {
     await confirmation("Attachment detected") { valueAttached in
       var configuration = Configuration()
       configuration.eventHandler = { event, _ in
-        guard case let .valueAttached(attachment) = event.kind else {
+        guard case let .valueAttached(attachment, _) = event.kind else {
           return
         }
 
         #expect(attachment.preferredName == temporaryFileName)
         #expect(throws: Never.self) {
-          try attachment.attachableValue.withUnsafeBufferPointer(for: attachment) { buffer in
+          try attachment.withUnsafeBufferPointer { buffer in
             #expect(buffer.count == data.count)
           }
         }
@@ -266,7 +266,7 @@ struct AttachmentTests {
     await confirmation("Attachment detected") { valueAttached in
       var configuration = Configuration()
       configuration.eventHandler = { event, _ in
-        guard case let .valueAttached(attachment) = event.kind else {
+        guard case let .valueAttached(attachment, _) = event.kind else {
           return
         }
 
@@ -356,19 +356,22 @@ struct AttachmentTests {
       name = "\(name).\(ext)"
     }
 
-    var attachment: Test.Attachment
+    func open<T>(_ attachment: borrowing Test.Attachment<T>) throws where T: Test.Attachable {
+      try attachment.attachableValue.withUnsafeBufferPointer(for: attachment) { bytes in
+        #expect(bytes.first == args.firstCharacter.asciiValue)
+        let decodedStringValue = try args.decode(Data(bytes))
+        #expect(decodedStringValue == "stringly speaking")
+      }
+    }
+
     if args.forSecureCoding {
       let attachableValue = MySecureCodingAttachable(string: "stringly speaking")
-      attachment = Test.Attachment(attachableValue, named: name)
+      let attachment = Test.Attachment(attachableValue, named: name)
+      try open(attachment)
     } else {
       let attachableValue = MyCodableAttachable(string: "stringly speaking")
-      attachment = Test.Attachment(attachableValue, named: name)
-    }
-
-    try attachment.attachableValue.withUnsafeBufferPointer(for: attachment) { bytes in
-      #expect(bytes.first == args.firstCharacter.asciiValue)
-      let decodedStringValue = try args.decode(Data(bytes))
-      #expect(decodedStringValue == "stringly speaking")
+      let attachment = Test.Attachment(attachableValue, named: name)
+      try open(attachment)
     }
   }