Added new project.

Author: NicolaLancellotti

Marvin-Tests/Basic Values/CustomResultTests.swift

@@ -0,0 +1,34 @@
+//
+// This source file is part of the Marvin open source project.
+// Copyright © 2018 Monk. All rights reserved.
+//
+
+import XCTest
+import Marvin
+
+class CustomResultTests: XCTestCase {
+    
+    func testErrorResult() {
+        typealias ErrorResult<T> = Result<T, Error>
+        
+        let error1: ErrorResult<Int> = .ok(10)
+        XCTAssert(error1.isOk)
+        let error2: ErrorResult<Int> = .err(GenericError(description: ""))
+        XCTAssert(error2.isErr)
+    }
+    
+    func testNetworkResult() {
+        enum NetworkError: Error, LocalizedError {
+            case ko
+            public var errorDescription: String? { return ""}
+        }
+        
+        typealias NetworkResult<T> = Result<T, NetworkError>
+        
+        let error1: NetworkResult<Int> = .ok(10)
+        XCTAssert(error1.isOk)
+        let error2: NetworkResult<Int> = .err(.ko)
+        XCTAssert(error2.isErr)
+    }
+    
+}

Marvin-Tests/Basic Values/ResultTests.swift

@@ -0,0 +1,51 @@
+//
+// This source file is part of the Marvin open source project.
+// Copyright © 2018 Monk. All rights reserved.
+//
+
+import XCTest
+import Marvin
+
+class ResultTests: XCTestCase {
+    
+    func testOk() {
+        var resultOk: Result<Int, String>
+        resultOk = .ok(1)
+        XCTAssert(resultOk.isOk)
+        XCTAssert(resultOk.ok == .some(1))
+        XCTAssert(resultOk.map({ (value) -> String in String(value)}) == .ok("1"))
+        XCTAssert(resultOk.mapErr({ (err) -> Int in err.count}).ok! == 1)
+        
+        
+        let result1 = resultOk.flatMap({ (value: Int) -> Result<String, String> in
+            Result.ok("ok")
+        })
+        XCTAssert(result1.ok! == "ok")
+        
+        
+        let result2 = resultOk.flatMap({ (value: Int) -> Result<String, String> in
+            Result.err("e")
+        })
+        XCTAssert(result2.err! == "e")
+    }
+    
+    func testErr() {
+        var resultErr: Result<Int32, String>
+        resultErr = .err("error")
+        XCTAssert(resultErr.isErr)
+        XCTAssert(resultErr.err == .some("error"))
+        XCTAssert(resultErr.map({ (value) -> String in String(value)}) == .err("error"))
+        XCTAssert(resultErr.mapErr({ (err) -> Int in err.count}).err! == 5)
+        
+        
+        let result1 = resultErr.flatMapErr({ (err: String) -> Result<Int32, Int> in
+            Result.ok(1)
+        })
+        XCTAssert(result1.ok! == 1)
+
+        let result2 = resultErr.flatMapErr({ (err: String) -> Result<Int32, Int> in
+            Result.err(1)
+        })
+        XCTAssert(result2.err! == 1)
+    }
+}

Marvin-Tests/Errors/GenericErrorTests.swift

@@ -0,0 +1,16 @@
+//
+// This source file is part of the Marvin open source project.
+// Copyright © 2018 Monk. All rights reserved.
+//
+
+import XCTest
+import Marvin
+
+class GenericErrorTests: XCTestCase {
+    
+    func testExample() {
+        let e: Error = GenericError(description: "test")
+        XCTAssertEqual(e.localizedDescription, "test")
+    }
+    
+}

Marvin-Tests/Network/NetworkTests.swift

@@ -0,0 +1,159 @@
+//
+// This source file is part of the Marvin open source project.
+// Copyright © 2018 Monk. All rights reserved.
+//
+
+import XCTest
+import Marvin
+
+func currentQueueName() -> String? {
+    let name = __dispatch_queue_get_label(nil)
+    return String(cString: name, encoding: .utf8)
+}
+
+class NetworkTests: XCTestCase {
+    
+    // _____________________________________________________________________________
+    // MARK: - Queues
+    
+    func test_sync_fromMain() {
+        Network.execute(mode: .sync, request: Requests.testGet(id: 1)) { _ in
+            XCTAssert(Thread.isMainThread)
+        }
+    }
+    
+    func test_Sync_NotFromMain() {
+        let exp = expectation(description: "test_sync_fromMain")
+        let queue = DispatchQueue(label: "test_sync_fromMain", qos: .default);
+        
+        queue.async {
+            Network.execute(mode: .sync,
+                            request: Requests.testGet(id: 1))
+            { _ in
+                XCTAssertEqual(currentQueueName(), "test_sync_fromMain")
+                exp.fulfill()
+            }
+        }
+        wait(for: [exp], timeout: 60);
+    }
+    
+    func test_async() {
+        let exp = expectation(description: "test_async")
+        let queue = DispatchQueue(label: "test_async", qos: .default);
+        
+        Network.execute(mode: .async(responseQueue: queue),
+                        request: Requests.testGet(id: 1))
+        { _ in
+            XCTAssertEqual(currentQueueName(), "test_async")
+            exp.fulfill()
+        }
+        
+        wait(for: [exp], timeout: 60);
+    }
+    
+    // _____________________________________________________________________________
+    // MARK: - Methods
+    
+    func test_get_custom() {
+        Network.execute(mode: .sync,
+                        request: Requests.testGetCustom(id: 1))
+        { result in
+            switch result {
+            case .ok(let response): XCTAssert(response.item.userId == 1)
+            case .err(let error): XCTFail(error.localizedDescription)
+            }
+        }
+    }
+    
+    func test_get() {
+        let req = Requests.testGet(id: 12)
+        
+        Network.execute(mode: .sync,
+                        request: req)
+        { result in
+            switch result {
+            case .ok(let item):
+                print(item)
+            case .err(let e):
+                switch e {
+                case .networkError(_): break
+                case .parseJSONError(_): break
+                }
+            }
+        }
+    }
+    
+    func test_delete() {
+        let item = Item(userId: 1, title: "title", body: "body")
+        let req = Requests.testDelete(item: item)
+        
+        Network.execute(mode: .sync,
+                        request: req)
+        { result in
+            switch result {
+            case .ok(let item):
+                print(item)
+            case .err(let e):
+                switch e {
+                case .networkError(_): break
+                case .parseJSONError(_): break
+                }
+            }
+        }
+    }
+    
+    func test_operation() {
+        let exp = expectation(description: "test_operation")
+        
+        let item = Item(userId: 1, title: "title", body: "body")
+        let operation = DeleteOperation(item: item)
+        operation.completionBlock = {
+            exp.fulfill()
+        }
+        OperationQueue().addOperation(operation)
+        
+        waitForExpectations(timeout: 10) { error in
+            if error != nil {
+                XCTFail()
+            }
+        }
+        
+    }
+}
+
+
+class DeleteOperation: Operation, Codable {
+    
+    let item: Item
+    
+    init(item: Item) {
+        self.item = item
+    }
+    
+    override func main() {
+        let req = Requests.testDelete(item: item)
+        
+        Network.execute(mode: .sync,
+                        request: req)
+        { result in
+            switch result {
+            case .ok(_):
+                break
+            case .err(let error):
+                XCTFail(error.localizedDescription)
+            }
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+

Marvin-Tests/Network/Requests.swift

@@ -0,0 +1,63 @@
+//
+// This source file is part of the Marvin open source project.
+// Copyright © 2018 Monk. All rights reserved.
+//
+
+import Foundation
+import Marvin
+
+enum Requests {
+    static let endpoint = URL(string: "https://jsonplaceholder.typicode.com")!
+    
+    struct Empty: Codable {
+        
+    }
+    
+    static func testGet(id: Int) -> NetworkRequest<Item> {
+        return NetworkRequest(path: endpoint + "posts/\(id)",
+                               method: .get,
+                               response: Item.self)
+    }
+    
+    static func testDelete(item: Item) -> NetworkRequest<Empty> {
+        let path = endpoint + "posts\(item.userId)"
+        let body = try! JSONEncoder().encode(item)
+        return NetworkRequest(path: path,
+                              method: .delete,
+                              headers: nil,
+                              bodyAsJSON: body,
+                              queryString: nil,
+                              response: Empty.self)
+    
+    }
+    
+    static func testGetCustom(id: Int) -> NetworkRequestWithCustomResponse<CustomTestGetResponse> {
+        return NetworkRequestWithCustomResponse(path: endpoint + "posts/\(id)",
+                                                 method: .get,
+                                                 headers: nil,
+                                                 bodyAsJSON: nil,
+                                                 queryString: nil,
+                                                 response: CustomTestGetResponse.self)
+    }
+
+}
+
+
+struct Item: Codable {
+    let userId: Int
+    let title: String
+    let body: String
+}
+
+
+struct CustomTestGetResponse: Response {
+    
+    let item: Item
+    
+    static func make(jsonData: Data) -> ErrorResult<CustomTestGetResponse> {
+        return CustomTestGetResponse.decode {
+            let item = try $0.decode(Item.self, from: jsonData)
+            return CustomTestGetResponse(item: item)
+        }
+    }
+}