Merge tag '1.3.0' into develop

Add global configuration, refactoring & updated testing

.gitea/workflows/hermes.yml

@@ -0,0 +1,20 @@
+name: Run Swift Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: macos
+
+    steps:
+    - name: ⬇️ Checkout code v3
+      uses: actions/checkout@v4
+
+    - name: 🛠️ Setup node
+      uses: actions/setup-node@v4
+
+    - name: 🧪 Test
+      run: swift test

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/.vscode
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Package.swift

@@ -0,0 +1,27 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Hermes",
+    platforms: [
+        .macOS(.v13),
+        .iOS(.v15)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "Hermes",
+            targets: ["Hermes"]),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "Hermes"),
+        .testTarget(
+            name: "HermesTests",
+            dependencies: ["Hermes"]),
+    ]
+)

README.md

@@ -17,5 +17,5 @@ You can use Swift Package Manager to integrate Hermes into your project. Add the
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/yourusername/Hermes.git", from: "1.0.0")
+    .package(url: "https://git.mahtan-melwasul.com/Mahtan/Hermes.git", from: "1.0.0")
 ]

Sources/Hermes/Hermes.swift

@@ -0,0 +1,148 @@
+//
+//  hermes.swift
+//
+//  Created by victor bodinaud on 11/01/2024.
+//
+
+import Foundation
+
+public enum NetworkError: Error {
+    case badRequest
+    case serverError(String)
+    case decodingError
+    case invalidResponse
+    case notFound
+}
+
+extension NetworkError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+            case .badRequest:
+                return NSLocalizedString("Unable to perform request", comment: "badRequestError")
+            case .serverError(let errorMessage):
+                return NSLocalizedString(errorMessage, comment: "serverError")
+            case .decodingError:
+                return NSLocalizedString("Unable to decode successfully", comment: "decodingError")
+            case .invalidResponse:
+                return NSLocalizedString("Invalid response", comment: "invalidResponse")
+            case .notFound:
+                return NSLocalizedString("Not Found", comment: "notFound")
+        }
+    }
+}
+
+public enum HTTPMethod {
+    case get([URLQueryItem]? = nil)
+    case post(Data?)
+    case put(Data?)
+    case patch(Data?)
+    case delete
+    
+    var name: String {
+        switch self {
+            case .get:
+                return "GET"
+            case .post:
+                return "POST"
+            case .put:
+                return "PUT"
+            case .patch:
+                return "PATCH"
+            case .delete:
+                return "DELETE"
+        }
+    }
+}
+
+public struct Resource<T: Codable> {
+    let url: URL
+    var method: HTTPMethod = .get([])
+    var modelType: T.Type
+    
+    public init(url: URL, method: HTTPMethod, modelType: T.Type) {
+        self.url = url
+        self.method = method
+        self.modelType = modelType
+    }
+}
+
+public final class Hermes {
+    public static let shared = Hermes()
+    private var config: HermesConfiguration
+    
+    private init(config: HermesConfiguration = HermesConfiguration()) {
+        self.config = config
+    }
+    
+    public func configure(_ config: HermesConfiguration) {
+        self.config = config
+    }
+    
+    private var defaultHeaders: [String: String] {
+        var headers = ["Content-Type": "application/json"]
+        if let token = UserDefaults.standard.string(forKey: "authToken") {
+            headers["Authorization"] = "Bearer \(token)"
+        }
+        headers.merge(config.defaultHeaders) { (_, new) in new }
+        return headers
+    }
+    
+    public func load<T: Codable>(_ resource: Resource<T>) async throws -> T {
+        
+        var request = URLRequest(url: resource.url)
+        request.httpMethod = resource.method.name
+        
+        switch resource.method {
+        case .get(let queryItems):
+            if let queryItems = queryItems {
+                var components = URLComponents(url: resource.url, resolvingAgainstBaseURL: false)
+                components?.queryItems = queryItems
+                request.url = components?.url
+            }
+        case .post(let data),
+             .put(let data),
+             .patch(let data):
+            request.httpBody = data
+        case .delete:
+            break
+        }
+        
+        request.allHTTPHeaderFields = defaultHeaders
+        
+        let configuration = URLSessionConfiguration.default
+        configuration.httpAdditionalHeaders = defaultHeaders
+        let session = URLSession(configuration: configuration)
+        
+        let (data, response) = try await session.data(for: request)
+        
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw NetworkError.invalidResponse
+        }
+        
+        try validate(response: httpResponse)
+        
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = config.decodingStrategy
+        
+        do {
+            return try decoder.decode(resource.modelType, from: data)
+        } catch {
+            throw NetworkError.decodingError
+        }
+    }
+    
+    private func validate(response: HTTPURLResponse) throws {
+        switch response.statusCode {
+            case 200...299:
+                return
+            case 400:
+                throw NetworkError.badRequest
+            case 404:
+                throw NetworkError.notFound
+            case 500:
+                throw NetworkError.serverError("Internal Server Error")
+            default:
+                throw NetworkError.invalidResponse
+        }
+    }
+}

Sources/Hermes/HermesConfiguration.swift

@@ -0,0 +1,18 @@
+//
+//  HermesConfiguration.swift
+//
+//
+//  Created by Victor on 28/05/2024.
+//
+
+import Foundation
+
+public struct HermesConfiguration {
+    var defaultHeaders: [String: String] = [:]
+    var decodingStrategy: JSONDecoder.KeyDecodingStrategy = .useDefaultKeys
+    
+    public init(defaultHeaders: [String: String] = [:], decodingStrategy: JSONDecoder.KeyDecodingStrategy = .useDefaultKeys) {
+        self.defaultHeaders = defaultHeaders
+        self.decodingStrategy = decodingStrategy
+    }
+}

Tests/HermesTests/HermesTests.swift

@@ -0,0 +1,139 @@
+@testable import Hermes
+import XCTest
+
+final class HermesTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        configureHermes()
+    }
+    
+    private func configureHermes() {
+        let defaultHeaders = ["Custom-Header": "HeaderValue"]
+        let decodingStrategy = JSONDecoder.KeyDecodingStrategy.convertFromSnakeCase
+        let config = HermesConfiguration(defaultHeaders: defaultHeaders, decodingStrategy: decodingStrategy)
+        Hermes.shared.configure(config)
+    }
+    
+    func testGetRequest() async throws {
+        let queryParams = [URLQueryItem(name: "foo", value: "bar")]
+        let resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(queryParams), modelType: GetResponse.self)
+        
+        let getResponse = try await Hermes.shared.load(resource)
+        
+        XCTAssertEqual(getResponse.url, "https://httpbin.org/get?foo=bar")
+        XCTAssertEqual(getResponse.args.count, 1)
+        XCTAssertGreaterThan(getResponse.headers.count, 0)
+    }
+    
+    func testPostRequest() async throws {
+        let postDatas = try? JSONEncoder().encode(["foo": "bar"])
+        let resource = Resource(url: URL(string: "https://httpbin.org/post")!, method: .post(postDatas), modelType: PostResponse.self)
+        
+        let postResponse = try await Hermes.shared.load(resource)
+        
+        XCTAssertEqual(postResponse.url, "https://httpbin.org/post")
+        XCTAssertEqual(postResponse.args.count, 0)
+        XCTAssertNotNil(postResponse.json)
+        XCTAssertEqual(postResponse.json?.count, 1)
+        XCTAssertGreaterThan(postResponse.headers.count, 0)
+    }
+    
+    func testPutRequest() async throws {
+        let postDatas = try? JSONEncoder().encode(["foo": "bar"])
+        let resource = Resource(url: URL(string: "https://httpbin.org/put")!, method: .put(postDatas), modelType: PostResponse.self)
+        
+        let putResponse = try await Hermes.shared.load(resource)
+        
+        XCTAssertEqual(putResponse.url, "https://httpbin.org/put")
+        XCTAssertEqual(putResponse.args.count, 0)
+        XCTAssertNotNil(putResponse.json)
+        XCTAssertEqual(putResponse.json?.count, 1)
+        XCTAssertGreaterThan(putResponse.headers.count, 0)
+    }
+    
+    func testPatchRequest() async throws {
+        let postDatas = try? JSONEncoder().encode(["foo": "bar"])
+        let resource = Resource(url: URL(string: "https://httpbin.org/patch")!, method: .patch(postDatas), modelType: PostResponse.self)
+        
+        let patchResponse = try await Hermes.shared.load(resource)
+        
+        XCTAssertEqual(patchResponse.url, "https://httpbin.org/patch")
+        XCTAssertEqual(patchResponse.args.count, 0)
+        XCTAssertNotNil(patchResponse.json)
+        XCTAssertEqual(patchResponse.json?.count, 1)
+        XCTAssertGreaterThan(patchResponse.headers.count, 0)
+    }
+    
+    func testDeleteRequest() async throws {
+        let resource = Resource(url: URL(string: "https://httpbin.org/delete")!, method: .delete, modelType: PostResponse.self)
+        
+        let deleteResponse = try await Hermes.shared.load(resource)
+        
+        XCTAssertEqual(deleteResponse.url, "https://httpbin.org/delete")
+        XCTAssertEqual(deleteResponse.args.count, 0)
+        XCTAssertNil(deleteResponse.json)
+        XCTAssertGreaterThan(deleteResponse.headers.count, 0)
+    }
+    
+    func testNotFound() async throws {
+        let resource = Resource(url: URL(string: "https://httpbin.org/status/404")!, method: .get(), modelType: GetResponse.self)
+        
+        do {
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.notFound")
+        } catch NetworkError.notFound {
+            XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+    
+    func testServerError() async throws {
+        let resource = Resource(url: URL(string: "https://httpbin.org/status/500")!, method: .get(), modelType: GetResponse.self)
+        
+        do {
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.serverError")
+        } catch NetworkError.serverError(_) {
+            XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+    
+    func testDecodeError() async throws {
+        let resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(), modelType: DummyResponse.self)
+        
+        do {
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.decodingError")
+        } catch NetworkError.decodingError {
+            XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+}
+
+struct GetResponse: Codable {
+    let args: [String: String]
+    let headers: [String: String]
+    let origin: String
+    let url: String
+}
+
+struct PostResponse: Codable {
+    let args: [String: String]
+    let data: String
+    let files: [String: String]
+    let form: [String: String]
+    let headers: [String: String]
+    let json: [String: String]?
+    let origin: String
+    let url: String
+}
+
+struct DummyResponse: Codable {
+    let dumb: Int
+    let dumber: Double
+}