Create HTTP Post

Sources/Frisbee/Entities/FrisbeeEncodable.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+protocol FrisbeeEncodable {
+    func encode<T: Encodable>(_ value: T) throws -> Data
+}

Sources/Frisbee/Entities/FrisbeeJSONEncoder.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+class FrisbeeJSONEncoder: FrisbeeEncodable {
+    func encode<T: Encodable>(_ value: T) throws -> Data {
+        return try JSONEncoder().encode(value)
+    }
+}

Sources/Frisbee/Entities/FrisbeeJSONSerializable.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+class FrisbeeJSONSerializable: FrisbeeSerializable {
+    func object(with data: Data, options opt: JSONSerialization.ReadingOptions = []) throws -> Any {
+        return try JSONSerialization.jsonObject(with: data, options: opt)
+    }
+}

Sources/Frisbee/Entities/FrisbeeSerializable.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+protocol FrisbeeSerializable {
+    func object(with data: Data, options opt: JSONSerialization.ReadingOptions) throws -> Any
+}

Sources/Frisbee/Entities/Result.swift

@@ -1,10 +1,10 @@
-public enum Result<Entity> {
-    case success(Entity)
+public enum Result<T> {
+    case success(T)
     case fail(FrisbeeError)
 }
 
 extension Result {
-    public var data: Entity? {
+    public var data: T? {
         guard case let .success(data) = self else {
             return nil
         }
@@ -30,7 +30,7 @@ extension Result: Equatable {
     }
 }
 
-extension Result where Entity: Equatable {
+extension Result where T: Equatable {
     public static func == (lhs: Result, rhs: Result) -> Bool {
         switch (lhs, rhs) {
         case let (.success(lhs), .success(rhs)):

Sources/Frisbee/Factories/BodyBuildableFactory.swift

@@ -0,0 +1,8 @@
+struct BodyBuildableFactory {
+
+    static func make() -> BodyBuildable {
+        return BodyBuilder(encoder: FrisbeeEncodableFactory.make(),
+                           serializer: FrisbeeJSONSerializableFactroy.make())
+    }
+
+}

Sources/Frisbee/Factories/FrisbeeEncodableFactory.swift

@@ -0,0 +1,7 @@
+class FrisbeeEncodableFactory {
+
+    static func make() -> FrisbeeEncodable {
+        return FrisbeeJSONEncoder()
+    }
+
+}

Sources/Frisbee/Factories/FrisbeeJSONSerializableFactroy.swift

@@ -0,0 +1,7 @@
+class FrisbeeJSONSerializableFactroy {
+
+    static func make() -> FrisbeeSerializable {
+        return FrisbeeJSONSerializable()
+    }
+
+}

Sources/Frisbee/Factories/ResultGeneratorFactory.swift

@@ -1,6 +1,6 @@
 struct ResultGeneratorFactory {
 
-    static func make<Entity: Decodable>() -> ResultGenerator<Entity> {
+    static func make<T: Decodable>() -> ResultGenerator<T> {
         return ResultGenerator(decoder: FrisbeeDecodableFacotry.make())
     }
 

Sources/Frisbee/Factories/URLRequestFactory.swift

@@ -5,6 +5,8 @@ struct URLRequestFactory {
     static func make(_ httpMethod: HTTPMethod, _ url: URL) -> URLRequest {
         var request = URLRequest(url: url)
         request.httpMethod = httpMethod.rawValue
+        request.setValue("application/json; charset=utf-8", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json; charset=utf-8", forHTTPHeaderField: "Accept")
 
         return request
     }

Sources/Frisbee/Interactors/BodyBuildable.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+protocol BodyBuildable {
+    func build<T: Encodable>(withBody body: T) throws -> [String: Any]
+}

Sources/Frisbee/Interactors/BodyBuilder.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+struct BodyBuilder: BodyBuildable {
+
+    private let encoder: FrisbeeEncodable
+    private let serializer: FrisbeeSerializable
+
+    init(encoder: FrisbeeEncodable, serializer: FrisbeeSerializable) {
+        self.encoder = encoder
+        self.serializer = serializer
+    }
+
+    func build<T: Encodable>(withBody body: T) throws -> [String: Any] {
+        var json: [String: Any] = [:]
+
+        let data = try encoder.encode(body)
+        let jsonObject = try serializer.object(with: data, options: [])
+        if let jsonDictionary = jsonObject as? [String: Any] { json = jsonDictionary }
+
+        return json
+    }
+
+}

Sources/Frisbee/Interactors/DataTaskRunner.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+final class DataTaskRunner {
+
+    static func run<T: Decodable>(with urlSession: URLSession, request: URLRequest,
+                                  onComplete: @escaping OnComplete<T>) {
+        let task = urlSession.dataTask(with: request) { data, _, error in
+            onComplete(ResultGeneratorFactory.make().generate(data: data, error: error))
+        }
+
+        task.resume()
+    }
+
+}

Sources/Frisbee/Interactors/QueryItemBuilder.swift

@@ -1,8 +1,8 @@
 import Foundation
 
-struct QueryItemBuilder<Entity: Encodable> {
+struct QueryItemBuilder<T: Encodable> {
 
-    static func build(withEntity entity: Entity) throws -> [URLQueryItem] {
+    static func build(withEntity entity: T) throws -> [URLQueryItem] {
         var json: [String: Any] = [:]
 
         let data = try JSONEncoder().encode(entity)

Sources/Frisbee/Interactors/ResultGenerator.swift

@@ -1,18 +1,18 @@
 import Foundation
 
-struct ResultGenerator<Entity: Decodable> {
+struct ResultGenerator<T: Decodable> {
 
     private let decoder: FrisbeeDecodable
 
     init(decoder: FrisbeeDecodable) {
         self.decoder = decoder
     }
 
-    func generate(data: Data?, error: Error?) -> Result<Entity> {
+    func generate(data: Data?, error: Error?) -> Result<T> {
         if let data = data {
-            let result: Result<Entity>
+            let result: Result<T>
             do {
-                let entityDecoded = try decoder.decode(Entity.self, from: data)
+                let entityDecoded = try decoder.decode(T.self, from: data)
                 result = Result.success(entityDecoded)
             } catch {
                 let noDataError = FrisbeeError.noData

Sources/Frisbee/Interactors/URLWithQueryBuildable.swift

@@ -1,6 +1,6 @@
 import Foundation
 
 protocol URLWithQueryBuildable {
-    func build<Query: Encodable>(withUrl url: String, query: Query) throws -> URL
-    func build<Query: Encodable>(withUrl url: URL, query: Query) throws -> URL
+    func build<T: Encodable>(withUrl url: String, query: T) throws -> URL
+    func build<T: Encodable>(withUrl url: URL, query: T) throws -> URL
 }

Sources/Frisbee/Interactors/URLWithQueryBuilder.swift

@@ -2,14 +2,14 @@ import Foundation
 
 struct URLWithQueryBuilder: URLWithQueryBuildable {
 
-    func build<Query: Encodable>(withUrl url: String, query: Query) throws -> URL {
+    func build<T: Encodable>(withUrl url: String, query: T) throws -> URL {
         guard let actualUrl = URL(string: url) else {
             throw FrisbeeError.invalidUrl
         }
         return try build(withUrl: actualUrl, query: query)
     }
 
-    func build<Query: Encodable>(withUrl url: URL, query: Query) throws -> URL {
+    func build<T: Encodable>(withUrl url: URL, query: T) throws -> URL {
         var url = url
         var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: true)
         urlComponents?.queryItems = try QueryItemBuilder.build(withEntity: query)

Sources/Frisbee/Requestables/Getable.swift

@@ -1,10 +1,8 @@
 import Foundation
 
 public protocol Getable {
-    func get<Entity: Decodable>(url: String, onComplete: @escaping (Result<Entity>) -> Void)
-    func get<Entity: Decodable>(url: URL, onComplete: @escaping (Result<Entity>) -> Void)
-    func get<Entity: Decodable, Query: Encodable>(url: String, query: Query,
-                                                  onComplete: @escaping (Result<Entity>) -> Void)
-    func get<Entity: Decodable, Query: Encodable>(url: URL, query: Query,
-                                                  onComplete: @escaping (Result<Entity>) -> Void)
+    func get<T: Decodable>(url: String, onComplete: @escaping OnComplete<T>)
+    func get<T: Decodable>(url: URL, onComplete: @escaping OnComplete<T>)
+    func get<T: Decodable, U: Encodable>(url: String, query: U, onComplete: @escaping OnComplete<T>)
+    func get<T: Decodable, U: Encodable>(url: URL, query: U, onComplete: @escaping OnComplete<T>)
 }

Sources/Frisbee/Requestables/NetworkGet.swift

@@ -21,27 +21,25 @@ public class NetworkGet: Getable {
         self.urlSession = urlSession
     }
 
-    public func get<Entity: Decodable>(url: String, onComplete: @escaping (Result<Entity>) -> Void) {
+    public func get<T: Decodable>(url: String, onComplete: @escaping OnComplete<T>) {
         guard let url = URL(string: url) else {
             return onComplete(.fail(FrisbeeError.invalidUrl))
         }
         makeRequest(url: url, onComplete: onComplete)
     }
 
-    public func get<Entity: Decodable>(url: URL, onComplete: @escaping (Result<Entity>) -> Void) {
+    public func get<T: Decodable>(url: URL, onComplete: @escaping OnComplete<T>) {
         makeRequest(url: url, onComplete: onComplete)
     }
 
-    public func get<Entity: Decodable, Query: Encodable>(url: String, query: Query,
-                                                         onComplete: @escaping (Result<Entity>) -> Void) {
+    public func get<T: Decodable, U: Encodable>(url: String, query: U, onComplete: @escaping OnComplete<T>) {
         guard let url = URL(string: url) else {
             return onComplete(.fail(FrisbeeError.invalidUrl))
         }
         get(url: url, query: query, onComplete: onComplete)
     }
 
-    public func get<Entity: Decodable, Query: Encodable>(url: URL, query: Query,
-                                                         onComplete: @escaping (Result<Entity>) -> Void) {
+    public func get<T: Decodable, U: Encodable>(url: URL, query: U, onComplete: @escaping OnComplete<T>) {
         do {
             let url = try queryBuilder.build(withUrl: url, query: query)
             makeRequest(url: url, onComplete: onComplete)
@@ -50,14 +48,10 @@ public class NetworkGet: Getable {
         }
     }
 
-    private func makeRequest<Entity: Decodable>(url: URL, onComplete: @escaping (Result<Entity>) -> Void) {
+    private func makeRequest<T: Decodable>(url: URL, onComplete: @escaping (Result<T>) -> Void) {
         let request = URLRequestFactory.make(.GET, url)
 
-        let task = urlSession.dataTask(with: request) { data, _, error in
-            onComplete(ResultGeneratorFactory.make().generate(data: data, error: error))
-        }
-
-        task.resume()
+        DataTaskRunner.run(with: urlSession, request: request, onComplete: onComplete)
     }
 
 }

Sources/Frisbee/Requestables/NetworkPost.swift

@@ -0,0 +1,60 @@
+import Foundation
+
+public final class NetworkPost: Postable {
+
+    let urlSession: URLSession
+    private let bodyBuilder: BodyBuildable
+
+    public convenience init() {
+        self.init(urlSession: URLSessionFactory.make(), bodyBuilder: BodyBuildableFactory.make())
+    }
+
+    public convenience init(urlSession: URLSession) {
+        self.init(urlSession: urlSession, bodyBuilder: BodyBuildableFactory.make())
+    }
+
+    init(urlSession: URLSession, bodyBuilder: BodyBuildable) {
+        self.urlSession = urlSession
+        self.bodyBuilder = bodyBuilder
+    }
+
+    public func post<T: Decodable>(url: String, onComplete: @escaping OnComplete<T>) {
+        guard let url = URL(string: url) else {
+            return onComplete(.fail(FrisbeeError.invalidUrl))
+        }
+        makeRequest(url: url, onComplete: onComplete)
+    }
+
+    public func post<T: Decodable>(url: URL, onComplete: @escaping OnComplete<T>) {
+        makeRequest(url: url, onComplete: onComplete)
+    }
+
+    public func post<T: Decodable, U: Encodable>(url: String, body: U, onComplete: @escaping OnComplete<T>) {
+        guard let url = URL(string: url) else {
+            return onComplete(.fail(FrisbeeError.invalidUrl))
+        }
+        makeRequest(url: url, body: body, onComplete: onComplete)
+    }
+
+    public func post<T: Decodable, U: Encodable>(url: URL, body: U, onComplete: @escaping OnComplete<T>) {
+        makeRequest(url: url, body: body, onComplete: onComplete)
+    }
+
+    private func makeRequest<T: Decodable>(url: URL, onComplete: @escaping OnComplete<T>) {
+        let request = URLRequestFactory.make(.POST, url)
+        DataTaskRunner.run(with: urlSession, request: request, onComplete: onComplete)
+    }
+
+    private func makeRequest<T: Decodable, U: Encodable>(url: URL, body: U, onComplete: @escaping OnComplete<T>) {
+        var request = URLRequestFactory.make(.POST, url)
+        do {
+            let bodyObject = try bodyBuilder.build(withBody: body)
+            request.httpBody = try JSONSerialization.data(withJSONObject: bodyObject, options: [])
+        } catch {
+            return onComplete(.fail(FrisbeeError(error)))
+        }
+
+        DataTaskRunner.run(with: urlSession, request: request, onComplete: onComplete)
+    }
+
+}

Sources/Frisbee/Requestables/OnComplete.swift

@@ -0,0 +1 @@
+public typealias OnComplete<T: Decodable> = (Result<T>) -> Void

Sources/Frisbee/Requestables/Postable.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+protocol Postable {
+    func post<T: Decodable>(url: String, onComplete: @escaping OnComplete<T>)
+    func post<T: Decodable>(url: URL, onComplete: @escaping OnComplete<T>)
+    func post<T: Decodable, U: Encodable>(url: String, body: U, onComplete: @escaping OnComplete<T>)
+    func post<T: Decodable, U: Encodable>(url: URL, body: U, onComplete: @escaping OnComplete<T>)
+}

Tests/FrisbeeTests/Interactors/BodyBuilderTests.swift

@@ -0,0 +1,31 @@
+import XCTest
+@testable import Frisbee
+
+final class BodyBuilderTests: XCTestCase {
+
+    override func setUp() {
+        super.setUp()
+    }
+
+    func testBuildWithBodyWhenEncoderThrowsAnErrorThenThrows() {
+        let builder = BodyBuilder(encoder: FrisbeeThrowErrorFakeEncoder(),
+                                  serializer: FrisbeeJSONSerializableFactroy.make())
+
+        XCTAssertThrowsError(try builder.build(withBody: Fake(fake: "")))
+    }
+
+    func testBuildWithBodyWhenSerializerThrowsAnErrorThenThrows() {
+        let builder = BodyBuilder(encoder: FrisbeeEncodableFactory.make(),
+                                  serializer: FrisbeeThrowErrorFakeSerializer())
+
+        XCTAssertThrowsError(try builder.build(withBody: Fake(fake: "")))
+    }
+
+    static let allTests = [
+        ("testBuildWithBodyWhenEncoderThrowsAnErrorThenThrows",
+         testBuildWithBodyWhenEncoderThrowsAnErrorThenThrows),
+        ("testBuildWithBodyWhenSerializerThrowsAnErrorThenThrows",
+         testBuildWithBodyWhenSerializerThrowsAnErrorThenThrows)
+    ]
+
+}

Tests/FrisbeeTests/Interactors/ResultGeneratorTests.swift

@@ -1,27 +1,14 @@
 import XCTest
 @testable import Frisbee
 
-struct Fake: Codable { let fake: String }
-
-class FrisbeeStubDecodable: FrisbeeDecodable {
-    var error: FrisbeeError!
-
-    func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
-        throw error
-    }
-
-}
-
 final class ResultGeneratorTests: XCTestCase {
 
     private let someError = NSError(domain: "Some error", code: 33, userInfo: nil)
     private let fakeString = "Fake Fake"
 
     func testGenerateResultWhenEncoderTrhowAnerrorThenGenerateFailResult() {
-        let frisbeDecoder = FrisbeeStubDecodable()
-        frisbeDecoder.error = .invalidEntity
         let data = try? JSONEncoder().encode(Fake(fake: fakeString))
-        let resultGenerator = ResultGenerator<Fake>(decoder: frisbeDecoder)
+        let resultGenerator = ResultGenerator<Fake>(decoder: FrisbeeThrowErrorFakeDecodable())
 
         let result = resultGenerator.generate(data: data, error: nil)