Switch to Spectre for testing

.gitignore

@@ -0,0 +1 @@
+.conche/

Commander.podspec.json

@@ -19,5 +19,11 @@
   "platforms": {
     "ios": "8.0",
     "osx": "10.9"
+  },
+  "test_specification": {
+    "source_files": "CommanderSpecs/*Spec.swift",
+    "dependencies": {
+      "Spectre": [ "~> 0.5.0" ]
+    }
   }
 }

Commander/ArgumentConvertible.swift

@@ -1,4 +1,4 @@
-public enum ArgumentError : ErrorType, CustomStringConvertible {
+public enum ArgumentError : ErrorType, Equatable, CustomStringConvertible {
   case MissingValue(argument: String?)
 
   /// Value is not convertible to type
@@ -25,6 +25,21 @@ public enum ArgumentError : ErrorType, CustomStringConvertible {
   }
 }
 
+
+public func == (lhs: ArgumentError, rhs: ArgumentError) -> Bool {
+  switch (lhs, rhs) {
+  case let (.MissingValue(lhsKey), .MissingValue(rhsKey)):
+    return lhsKey == rhsKey
+  case let (.InvalidType(lhsValue, lhsType, lhsArgument), .InvalidType(rhsValue, rhsType, rhsArgument)):
+    return lhsValue == rhsValue && lhsType == rhsType && lhsArgument == rhsArgument
+  case let (.UnusedArgument(lhsArgument), .UnusedArgument(rhsArgument)):
+    return lhsArgument == rhsArgument
+  default:
+    return false
+  }
+}
+
+
 public protocol ArgumentConvertible : CustomStringConvertible {
   /// Initialise the type with an ArgumentParser
   init(parser: ArgumentParser) throws

Commander/ArgumentParser.swift

@@ -32,15 +32,20 @@ private enum Arg : CustomStringConvertible {
 }
 
 
-public struct ArgumentParserError : ErrorType, CustomStringConvertible {
-  public let description:String
+public struct ArgumentParserError : ErrorType, Equatable, CustomStringConvertible {
+  public let description: String
 
-  init(description:String) {
+  public init(_ description: String) {
     self.description = description
   }
 }
 
 
+public func ==(lhs: ArgumentParserError, rhs: ArgumentParserError) -> Bool {
+  return lhs.description == rhs.description
+}
+
+
 public final class ArgumentParser : ArgumentConvertible, CustomStringConvertible {
   private var arguments:[Arg]
 
@@ -130,7 +135,7 @@ public final class ArgumentParser : ArgumentConvertible, CustomStringConvertible
           case .Argument(let value):
             return value
           default:
-            throw ArgumentParserError(description: "Unexpected \(argument.type) `\(argument)` as a value for `--\(name)`")
+            throw ArgumentParserError("Unexpected \(argument.type) `\(argument)` as a value for `--\(name)`")
           }
         }
 
@@ -223,14 +228,14 @@ public final class ArgumentParser : ArgumentConvertible, CustomStringConvertible
           case .Argument(let value):
             return value
           default:
-            throw ArgumentParserError(description: "Unexpected \(argument.type) `\(argument)` as a value for `-\(flag)`")
+            throw ArgumentParserError("Unexpected \(argument.type) `\(argument)` as a value for `-\(flag)`")
           }
         }
 
         throw ArgumentError.MissingValue(argument: "-\(flag)")
       }
     }
-    
+
     return nil
   }
 }

Commander/Group.swift

@@ -1,4 +1,4 @@
-public enum GroupError : ErrorType, CustomStringConvertible {
+public enum GroupError : ErrorType, Equatable, CustomStringConvertible {
   /// No-subcommand was found with the given name
   case UnknownCommand(String)
 
@@ -22,6 +22,17 @@ public enum GroupError : ErrorType, CustomStringConvertible {
   }
 }
 
+public func == (lhs: GroupError, rhs: GroupError) -> Bool {
+  switch (lhs, rhs) {
+  case let (.UnknownCommand(lhsCommand), .UnknownCommand(rhsCommand)):
+    return lhsCommand == rhsCommand
+  case let (.NoCommand(lhsPath, lhsGroup), .NoCommand(rhsPath, rhsGroup)):
+    return lhsPath == rhsPath && lhsGroup === rhsGroup
+  default:
+    return false
+  }
+}
+
 /// Represents a group of commands
 public class Group : CommandType {
   var commands = [String:CommandType]()

CommanderSpecs/ArgumentConvertibleSpec.swift

@@ -0,0 +1,95 @@
+import Spectre
+import Commander
+
+
+describe("ArgumentError") {
+  $0.it("has a human readable description for missing value") {
+    let error = ArgumentError.MissingValue(argument: nil)
+    try expect(error.description) == "Missing argument"
+  }
+
+  $0.it("has a human readable description for no value") {
+    let error = ArgumentError.InvalidType(value: "five", type: "number", argument: nil)
+    try expect(error.description) == "`five` is not a `number`"
+  }
+}
+
+describe("String ArgumentConvertible") {
+  $0.it("converts an argument to a string value") {
+    let parser = ArgumentParser(arguments: ["argument"])
+    let value = try String(parser: parser)
+
+    try expect(value) == "argument"
+  }
+
+  $0.it("handles when the argument parser doesn't have any values") {
+    let parser = ArgumentParser(arguments: [])
+    try expect(try String(parser: parser)).toThrow(ArgumentError.MissingValue(argument: nil))
+  }
+}
+
+describe("Int ArgumentConvertible") {
+  $0.it("converts a valid number as an integer") {
+    let parser = ArgumentParser(arguments: ["5"])
+    let value = try Int(parser: parser)
+
+    try expect(value) == 5
+  }
+
+  $0.it("errors on invalid input") {
+    let parser = ArgumentParser(arguments: ["five"])
+
+    try expect {
+      try Int(parser: parser)
+    }.toThrow(ArgumentError.InvalidType(value: "five", type: "number", argument: nil))
+  }
+
+  $0.it("handles when the argument parser doesn't have any values") {
+    let parser = ArgumentParser(arguments: [])
+    try expect(try Int(parser: parser)).toThrow(ArgumentError.MissingValue(argument: nil))
+  }
+}
+
+describe("Float ArgumentConvertible") {
+  $0.it("converts a valid number as an float") {
+    let parser = ArgumentParser(arguments: ["5"])
+    let value = try Float(parser: parser)
+
+    try expect(value) == 5
+  }
+
+  $0.it("errors on invalid input") {
+    let parser = ArgumentParser(arguments: ["five"])
+
+    try expect {
+      try Float(parser: parser)
+    }.toThrow(ArgumentError.InvalidType(value: "five", type: "number", argument: nil))
+  }
+
+  $0.it("handles when the argument parser doesn't have any values") {
+    let parser = ArgumentParser(arguments: [])
+    try expect(try Float(parser: parser)).toThrow(ArgumentError.MissingValue(argument: nil))
+  }
+}
+
+describe("Double ArgumentConvertible") {
+  $0.it("converts a valid number as an double") {
+    let parser = ArgumentParser(arguments: ["5"])
+    let value = try Double(parser: parser)
+
+    try expect(value) == 5
+  }
+
+  $0.it("errors on invalid input") {
+    let parser = ArgumentParser(arguments: ["five"])
+
+    try expect {
+      try Double(parser: parser)
+    }.toThrow(ArgumentError.InvalidType(value: "five", type: "number", argument: nil))
+  }
+
+  $0.it("handles when the argument parser doesn't have any values") {
+    let parser = ArgumentParser(arguments: [])
+    try expect(try Double(parser: parser)).toThrow(ArgumentError.MissingValue(argument: nil))
+  }
+}