Add Equatable conformance to RESPValue

Motivation:

While working on unit tests the need for conformance to `Equatable` for `RESPValue` has been needed a few times and it was decided to make it public.

Modifications:

Added conformance to `Equatable` for `RESPValue` with unit test.

Result:

Users should now be able to compare two `RESPValue` instances for equality.

Sources/RediStack/RESP/RESPValue.swift

@@ -129,3 +129,19 @@ extension RESPValue {
     /// - Note: This is a shorthand for `Array<UInt8>.init(fromRESP:)`.
     public var bytes: [UInt8]? { return [UInt8](fromRESP: self) }
 }
+
+// MARK: Equatable
+
+extension RESPValue: Equatable {
+    public static func == (lhs: RESPValue, rhs: RESPValue) -> Bool {
+        switch (lhs, rhs) {
+        case (.bulkString(let lhs), .bulkString(let rhs)): return lhs == rhs
+        case (.simpleString(let lhs), .simpleString(let rhs)): return lhs == rhs
+        case (.integer(let lhs), .integer(let rhs)): return lhs == rhs
+        case (.error(let lhs), .error(let rhs)): return lhs.message == rhs.message
+        case (.array(let lhs), .array(let rhs)): return lhs == rhs
+        case (.null, .null): return true
+        default: return false
+        }
+    }
+}

Tests/RediStackTests/RESPValueTests.swift

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the RediStack open source project
+//
+// Copyright (c) 2019 RediStack project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of RediStack project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import RediStack
+import XCTest
+
+final class RESPValueTests: XCTestCase {
+    func test_equatable() {
+        let redisError = RedisError(reason: "testing")
+        
+        let null = RESPValue.null
+        let error = RESPValue.error(redisError)
+        let array = RESPValue.array([.null, error])
+        let integer = RESPValue.integer(3)
+        let simpleString = RESPValue.simpleString("OK".byteBuffer)
+        let bulkString = RESPValue.bulkString(nil)
+        
+        XCTAssertEqual(null, .null)
+        XCTAssertNotEqual(null, error)
+        XCTAssertNotEqual(null, array)
+        XCTAssertNotEqual(null, integer)
+        XCTAssertNotEqual(null, simpleString)
+        XCTAssertNotEqual(null, bulkString)
+        
+        XCTAssertEqual(error, .error(redisError))
+        XCTAssertNotEqual(error, .error(RedisError(reason: "failure")))
+        XCTAssertNotEqual(error, integer)
+        XCTAssertNotEqual(error, simpleString)
+        XCTAssertNotEqual(error, bulkString)
+        XCTAssertNotEqual(error, array)
+        
+        XCTAssertEqual(array, .array([.null, error]))
+        XCTAssertNotEqual(array, .array([integer]))
+        XCTAssertNotEqual(array, integer)
+        XCTAssertNotEqual(array, simpleString)
+        XCTAssertNotEqual(array, bulkString)
+        
+        XCTAssertEqual(integer, .integer(3))
+        XCTAssertNotEqual(integer, .integer(Int.max))
+        XCTAssertNotEqual(integer, simpleString)
+        XCTAssertNotEqual(integer, bulkString)
+        
+        XCTAssertEqual(simpleString, .simpleString("OK".byteBuffer))
+        XCTAssertNotEqual(simpleString, .simpleString(#function.byteBuffer))
+        XCTAssertNotEqual(simpleString, bulkString)
+        
+        XCTAssertEqual(bulkString, .bulkString(nil))
+        XCTAssertNotEqual(bulkString, .bulkString("OK".byteBuffer))
+    }
+}