Add convienence methods for "basic" commands

Author: Mordil

Sources/NIORedis/Commands/BasicCommands.swift

@@ -0,0 +1,65 @@
+import Foundation
+import NIO
+
+extension NIORedisConnection {
+    /// Select the Redis logical database having the specified zero-based numeric index.
+    /// New connections always use the database 0.
+    ///
+    /// https://redis.io/commands/select
+    public func select(_ id: Int) -> EventLoopFuture<Void> {
+        return command("SELECT", [RedisData(bulk: id.description)])
+            .map { _ in return () }
+    }
+
+    /// Removes the specified keys. A key is ignored if it does not exist.
+    ///
+    /// https://redis.io/commands/del
+    /// - Returns: A future number of keys that were removed.
+    public func delete(_ keys: String...) -> EventLoopFuture<Int> {
+        let keyArgs = keys.map { RedisData(bulk: $0) }
+        return command("DEL", keyArgs)
+            .thenThrowing { res in
+                guard let count = res.int else {
+                    throw RedisError(identifier: "delete", reason: "Unexpected response: \(res)")
+                }
+                return count
+            }
+    }
+
+    /// Set a timeout on key. After the timeout has expired, the key will automatically be deleted.
+    /// A key with an associated timeout is often said to be volatile in Redis terminology.
+    ///
+    /// https://redis.io/commands/expire
+    /// - Parameters:
+    ///     - after: The lifetime (in seconds) the key will expirate at.
+    /// - Returns: A future bool indicating if the expiration was set or not.
+    public func expire(_ key: String, after deadline: Int) -> EventLoopFuture<Bool> {
+        return command("EXPIRE", [RedisData(bulk: key), RedisData(bulk: deadline.description)])
+            .thenThrowing { res in
+                guard let value = res.int else {
+                    throw RedisError(identifier: "expire", reason: "Unexpected response: \(res)")
+                }
+                return value == 1
+            }
+    }
+
+    /// Get the value of a key.
+    /// If the key does not exist the value will be `nil`.
+    /// An error is resolved if the value stored at key is not a string, because GET only handles string values.
+    ///
+    /// https://redis.io/commands/get
+    public func get(_ key: String) -> EventLoopFuture<String?> {
+        return command("GET", [RedisData(bulk: key)])
+            .map { return $0.string }
+    }
+
+    /// Set key to hold the string value.
+    /// If key already holds a value, it is overwritten, regardless of its type.
+    /// Any previous time to live associated with the key is discarded on successful SET operation.
+    ///
+    /// https://redis.io/commands/set
+    public func set(_ key: String, to value: String) -> EventLoopFuture<Void> {
+        return command("SET", [RedisData(bulk: key), RedisData(bulk: value)])
+            .map { _ in return () }
+    }
+}

Tests/NIORedisTests/Commands/BasicCommandsTests.swift

@@ -0,0 +1,73 @@
+@testable import NIORedis
+import XCTest
+
+final class BasicCommandsTests: XCTestCase {
+    private let redis = NIORedis(executionModel: .spawnThreads(1))
+    deinit { try? redis.terminate() }
+
+    private var connection: NIORedisConnection?
+
+    override func setUp() {
+        do {
+            connection = try redis.makeConnection().wait()
+        } catch {
+            XCTFail("Failed to create NIORedisConnection!")
+        }
+    }
+
+    override func tearDown() {
+        _ = try? connection?.command("FLUSHALL").wait()
+        connection?.close()
+        connection = nil
+    }
+
+    func test_select() {
+        XCTAssertNoThrow(try connection?.select(3).wait())
+    }
+
+    func test_delete() throws {
+        let keys = [ #function + "1", #function + "2", #function + "3" ]
+        try connection?.set(keys[0], to: "value").wait()
+        try connection?.set(keys[1], to: "value").wait()
+        try connection?.set(keys[2], to: "value").wait()
+
+        let first = try connection?.delete(keys[0]).wait()
+        XCTAssertEqual(first, 1)
+
+        let second = try connection?.delete(keys[0]).wait()
+        XCTAssertEqual(second, 0)
+
+        let third = try connection?.delete(keys[1], keys[2]).wait()
+        XCTAssertEqual(third, 2)
+    }
+
+    func test_set() {
+        XCTAssertNoThrow(try connection?.set(#function, to: "value").wait())
+    }
+
+    func test_get() throws {
+        try connection?.set(#function, to: "value").wait()
+        let result = try connection?.get(#function).wait()
+        XCTAssertEqual(result, "value")
+    }
+
+    func test_expire() throws {
+        try connection?.set(#function, to: "value").wait()
+        let before = try connection?.get(#function).wait()
+        XCTAssertNotNil(before)
+
+        let result = try connection?.expire(#function, after: 0).wait()
+        XCTAssertEqual(result, true)
+
+        let after = try connection?.get(#function).wait()
+        XCTAssertNil(after)
+    }
+
+    static var allTests = [
+        ("test_select", test_select),
+        ("test_set", test_set),
+        ("test_get", test_get),
+        ("test_expire", test_expire),
+        ("test_delete", test_delete),
+    ]
+}

Tests/NIORedisTests/XCTestManifests.swift

@@ -9,6 +9,7 @@ public func allTests() -> [XCTestCaseEntry] {
         testCase(RedisDataDecoderByteToMessageDecoderTests.allTests),
         testCase(RedisDataEncoderTests.allTests),
         testCase(RedisDataEncoderParsingTests.allTests),
+        testCase(BasicCommandsTests.allTests),
     ]
 }
 #endif