Refactor dealer command and tests

Accept multiple arguments

Throw errors to indicate failure

Author: mattt

Package.swift

@@ -15,6 +15,9 @@ import PackageDescription
 
 let package = Package(
     name: "dealer",
+    platforms: [
+        .macOS(.v11)
+    ],
     products: [
         .executable(name: "dealer", targets: ["dealer"]),
     ],

Sources/dealer/Deal.swift

@@ -14,22 +14,33 @@ import Glibc
 
 import Foundation
 import DeckOfPlayingCards
+import PlayingCard
 import ArgumentParser
 
-var stdout = FileHandle.standardOutput
-var stderr = FileHandle.standardError
-
 @main
 struct Deal: ParsableCommand {
+    enum Error: Swift.Error, CustomStringConvertible {
+        case notEnoughCards
+
+        var description: String {
+            switch self {
+            case .notEnoughCards:
+                return "Not enough cards"
+            }
+        }
+    }
+
     static var configuration = CommandConfiguration(
             abstract: "Shuffles a deck of playing cards and deals a number of cards.",
             discussion: """
-                Prints each card to stdout until the deck is completely dealt,
-                and prints "No more cards" to stderr if there are no cards remaining.
+                For each count argument, prints a line of tab-delimited cards to stdout,
+                or if there aren't enough cards remaining,
+                prints "Not enough cards" to stderr and exits with a nonzero status.
                 """)
 
-    @Argument(help: "The number of cards to deal.")
-    var count: UInt = 10
+    @Argument(help: .init("The number of cards to deal at a time.",
+                          valueName: "count"))
+    var counts: [UInt]
 
     mutating func run() throws {
         #if os(Linux)
@@ -39,13 +50,18 @@ struct Deal: ParsableCommand {
         var deck = Deck.standard52CardDeck()
         deck.shuffle()
 
-        for _ in 0..<count {
-            guard let card = deck.deal() else {
-                print("No more cards", to: &stderr)
-                break
+        for count in counts {
+            var cards: [PlayingCard] = []
+
+            for _ in 0..<count {
+                guard let card = deck.deal() else {
+                    Self.exit(withError: Error.notEnoughCards)
+                }
+
+                cards.append(card)
             }
 
-            print(card, to: &stdout)
+            print(cards.map(\.description).joined(separator: "\t"))
         }
     }
 }

Sources/dealer/FileWrapper+Extensions.swift

@@ -12,35 +12,43 @@ import XCTest
 import class Foundation.Bundle
 
 final class DealerTests: XCTestCase {
-    func testExample() throws {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct
-        // results.
-
-        // Some of the APIs that we use below are available in macOS 10.13 and above.
-        guard #available(macOS 10.13, *) else {
-            return
-        }
+    func testUsage() throws {
+        let (status, output, error) = try execute(with: ["--help"])
+        XCTAssertEqual(status, EXIT_SUCCESS)
+        XCTAssert(output?.starts(with: "OVERVIEW: Shuffles a deck of playing cards and deals a number of cards.") ?? false)
+        XCTAssertEqual(error, "")
+    }
 
-        // Mac Catalyst won't have `Process`, but it is supported for executables.
-        #if !targetEnvironment(macCatalyst)
+    func testDealOneCard() throws {
+        let (status, output, error) = try execute(with: ["1"])
+        XCTAssertEqual(status, EXIT_SUCCESS)
+        XCTAssertEqual(output?.filter(\.isPlayingCardSuit).count, 1)
 
-        let dealerBinary = productsDirectory.appendingPathComponent("dealer")
+        XCTAssertEqual(error, "")
+    }
 
-        let process = Process()
-        process.executableURL = dealerBinary
+    func testDealTenCards() throws {
+        let (status, output, error) = try execute(with: ["10"])
+        XCTAssertEqual(status, EXIT_SUCCESS)
+        XCTAssertEqual(output?.filter(\.isPlayingCardSuit).count, 10)
 
-        let pipe = Pipe()
-        process.standardOutput = pipe
+        XCTAssertEqual(error, "")
+    }
 
-        try process.run()
-        process.waitUntilExit()
+    func testDealThirteenCardsFourTimes() throws {
+        let (status, output, error) = try execute(with: ["13", "13", "13", "13"])
+        XCTAssertEqual(status, EXIT_SUCCESS)
+        XCTAssertEqual(output?.filter(\.isPlayingCardSuit).count, 52)
+        XCTAssertEqual(output?.filter(\.isNewline).count, 4)
 
-        let data = pipe.fileHandleForReading.readDataToEndOfFile()
-        let output = String(data: data, encoding: .utf8)
+        XCTAssertEqual(error, "")
+    }
 
-        XCTAssertNotEqual(output, "")
-        #endif
+    func testDealOneHundredCards() throws {
+        let (status, output, error) = try execute(with: ["100"])
+        XCTAssertNotEqual(status, EXIT_SUCCESS)
+        XCTAssertEqual(output, "")
+        XCTAssertEqual(error, "Error: Not enough cards\n")
     }
 
     /// Returns path to the built products directory.
@@ -54,4 +62,42 @@ final class DealerTests: XCTestCase {
         return Bundle.main.bundleURL
       #endif
     }
+
+    private func execute(with arguments: [String] = []) throws -> (status: Int32, output: String?, error: String?) {
+        let process = Process()
+        process.executableURL = productsDirectory.appendingPathComponent("dealer")
+        process.arguments = arguments
+
+        let outputPipe = Pipe()
+        process.standardOutput = outputPipe
+
+        let errorPipe = Pipe()
+        process.standardError = errorPipe
+
+        try process.run()
+        process.waitUntilExit()
+
+        let status = process.terminationStatus
+
+        let outputData = outputPipe.fileHandleForReading.readDataToEndOfFile()
+        let output = String(data: outputData, encoding: .utf8)
+
+        let errorData = errorPipe.fileHandleForReading.readDataToEndOfFile()
+        let error = String(data: errorData, encoding: .utf8)
+
+        return (status, output, error)
+    }
+}
+
+// MARK: -
+
+private extension Character {
+    var isPlayingCardSuit: Bool {
+        switch self {
+        case "♠︎", "♡", "♢", "♣︎":
+            return true
+        default:
+            return false
+        }
+    }
 }