Merge pull request '[Testing and Reliability] Unit Testing & CI' (#25) from feature/unit-testing into main

Reviewed-on: #25

.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

@@ -1,5 +1,6 @@
 .DS_Store
 /.build
+/.vscode
 /Packages
 xcuserdata/
 DerivedData/

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

@@ -11,6 +11,7 @@ public enum NetworkError: Error {
     case serverError(String)
     case decodingError
     case invalidResponse
+    case notFound
 }
 
 extension NetworkError: LocalizedError {
@@ -19,19 +20,22 @@ extension NetworkError: LocalizedError {
             case .badRequest:
                 return NSLocalizedString("Unable to perform request", comment: "badRequestError")
             case .serverError(let errorMessage):
-                print(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])
+    case get([URLQueryItem]? = nil)
     case post(Data?)
+    case put(Data?)
+    case patch(Data?)
     case delete
     
     var name: String {
@@ -40,6 +44,10 @@ public enum HTTPMethod {
                 return "GET"
             case .post:
                 return "POST"
+            case .put:
+                return "PUT"
+            case .patch:
+                return "PATCH"
             case .delete:
                 return "DELETE"
         }
@@ -62,6 +70,18 @@ public struct Hermes {
     
     public init() { }
     
+    private var defaultHeaders: [String: String] {
+        var headers = ["Content-Type": "application/json"]
+        let defaults = UserDefaults.standard
+        guard let token = defaults.string(forKey: "authToken") else {
+            return headers
+        }
+        
+        headers["Authorization"] = "Bearer \(token)"
+        
+        return headers
+    }
+    
     public func load<T: Codable>(_ resource: Resource<T>) async throws -> T {
         
         var request = URLRequest(url: resource.url)
@@ -76,7 +96,9 @@ public struct Hermes {
             
             request = URLRequest(url: url)
             
-        case .post(let data):
+        case .post(let data),
+             .put(let data),
+             .patch(let data):
             request.httpMethod = resource.method.name
             request.httpBody = data
             
@@ -85,15 +107,26 @@ public struct Hermes {
         }
         
         let configuration = URLSessionConfiguration.default
-        configuration.httpAdditionalHeaders = ["Content-Type": "application/json"]
+        configuration.httpAdditionalHeaders = defaultHeaders
         let session = URLSession(configuration: configuration)
         
         let (data, response) = try await session.data(for: request)
         
-        guard let _ = response as? HTTPURLResponse else {
+        guard let response = response as? HTTPURLResponse else {
             throw NetworkError.invalidResponse
         }
         
+        if response.statusCode != 200 {
+            switch response.statusCode {
+                case 404:
+                    throw NetworkError.notFound
+                case 500:
+                    throw NetworkError.serverError(response.description)
+                default:
+                    throw NetworkError.invalidResponse
+            }
+        }
+        
         guard let result = try? JSONDecoder().decode(resource.modelType, from: data) else {
             throw NetworkError.decodingError
         }

Tests/HermesTests/HermesTests.swift

@@ -2,11 +2,126 @@ import XCTest
 @testable import Hermes
 
 final class HermesTests: XCTestCase {
-    func testExample() throws {
-        // XCTest Documentation
-        // https://developer.apple.com/documentation/xctest
-
-        // Defining Test Cases and Test Methods
-        // https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
+    
+    func testGetRequest() async throws {
+        let hermes = Hermes()
+        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.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 hermes = Hermes()
+        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.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 hermes = Hermes()
+        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.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 hermes = Hermes()
+        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.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 hermes = Hermes()
+        let resource = Resource(url: URL(string: "https://httpbin.org/delete")!, method: .delete, modelType: PostResponse.self)
+        
+        let deleteResponse = try await hermes.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 hermes = Hermes()
+        let resource = Resource(url: URL(string: "https://httpbin.org/status/404")!, method: .get(), modelType: GetResponse.self)
+        
+        do {
+            let _ = try await hermes.load(resource)
+        } catch NetworkError.notFound {
+            XCTAssert(true)
+        }
+    }
+    
+    func testServerError() async throws {
+        let hermes = Hermes()
+        let resource = Resource(url: URL(string: "https://httpbin.org/status/500")!, method: .get(), modelType: GetResponse.self)
+        
+        do {
+            let _ = try await hermes.load(resource)
+        } catch NetworkError.serverError(_) {
+            XCTAssert(true)
+        }
+    }
+    
+    func testDecodeError() async throws {
+        let hermes = Hermes()
+        let resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(), modelType: DummyResponse.self)
+        
+        do {
+            let _ = try await hermes.load(resource)
+        } catch NetworkError.decodingError {
+            XCTAssert(true)
+        }
     }
 }
+
+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
+}