Clean Architecture Network Module

 

 

 

 

Clean Architecture 기반하여

네트워크를 추상화, 모듈화하는 코드를 정리하려고 합니다

 

 

 

 

 

Clean Architecture에서 네트워크 계층은 다음과 같은 레이어로 나눌 수 있습니다

 

- Domain Layer: 앱의 핵심 비즈니스 로직과 규칙을 정의합니다

- Data Layer: 외부 데이터 소스(네트워크, 데이터베이스 등)와의 상호작용을 처리합니다

- Presentation Layer: UI와 상호작용하며, 사용자에게 데이터를 보여줍니다

 

 

이중에서 network 로직은 Data Layer에 포함됩니다.

 

 

 

 

먼저 

네트워크 세션의 동작 구현하는 URLSessionWrapper를 작성합니다.

import Foundation

public protocol SessionProtocol {
    func performRequest(_ url: URLRequest) async throws -> (Data, URLResponse)
}

public class URLSessionWrapper: SessionProtocol {
    private let session: URLSession

    public init(session: URLSession = .shared) {
        self.session = session
    }

    public func performRequest(_ url: URLRequest) async throws -> (Data, URLResponse) {
        return try await session.data(for: url)
    }
}

 

 

SessionProtocol를 채택하는 URLSessionWrapper를 사용함으로써

추후에 SessionProtocol로 만든 MockSession으로

URLSessionWrapper대신 사용하여 테스트 가능하도록 합니다

 

 

 

 

 

 

그 다음 실제 요청을 처리하는 NetworkManger 입니다.

import Foundation

public enum NetworkError: Error {
    case invalidURL
    case requestFailed(String)
    case dataNil
    case invalidResponse
    case decodingFailed(String)
    case serverError(Int)
}

public protocol NetworkManagerProtocol {
    func executeRequest<T: Decodable>(url: String,
                                      method: String,
                                      parameters: [String: Any]?) async -> Result<T, NetworkError>
}

public class NetworkManager: NetworkManagerProtocol {
    private let session: SessionProtocol

    public init(session: SessionProtocol) {
        self.session = session
    }

    public func executeRequest<T: Decodable>(url: String,
                                             method: String,
                                             parameters: [String: Any]?) async -> Result<T, NetworkError> {
        guard let url = URL(string: url) else {
            return .failure(.invalidURL)
        }

        var request = URLRequest(url: url)
        request.httpMethod = method
        if let parameters = parameters {
            request.httpBody = try? JSONSerialization.data(withJSONObject: parameters, options: [])
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        }

        do {
            let (data, response) = try await session.performRequest(request)
            guard let httpResponse = response as? HTTPURLResponse else {
                return .failure(.invalidResponse)
            }

            if (200..<300).contains(httpResponse.statusCode) {
                let decodedData = try JSONDecoder().decode(T.self, from: data)
                return .success(decodedData)
            } else {
                return .failure(.serverError(httpResponse.statusCode))
            }
        } catch {
            return .failure(.requestFailed(error.localizedDescription))
        }
    }
}

 

 

SessionProtocol을 의존성으로 주입 받아서

실제 HTTP 요청을 처리하는 NetworkManager 클래스를 만들어줍니다

NetworkManagerProtocol을 통해 추상화되어 있어 Mock 객체로 대체가 가능합니다

 

또 Generic을 사용하여 다양한 return 값에 재사용 가능합니다

 

 

 

 

 

 

그리고

사용자 데이터를 처리하는 네트워크 요청 로직 UserNetwork를 정의합니다.

import Foundation

public final class UserNetwork {
    private let manager: NetworkManagerProtocol

    public init(manager: NetworkManagerProtocol) {
        self.manager = manager
    }

    public func fetchUsers(query: String, page: Int) async -> Result<[User], NetworkError> {
        let url = "https://api.github.com/search/users?q=\(query)&page=\(page)"
        return await manager.executeRequest(url: url, method: "GET", parameters: nil)
    }
}

public struct User: Decodable {
    let id: Int
    let login: String
}

 

 

 

 

 

실제 호출에서는

URLSession을 구현하는 URLSessionWrapper() 선언하고

그리고 session을 실제 요청을 처리하는 NetworkManager의 session값으로 넣어줍니다

 

 

 

마지막으로 호출 url를 담고 있는 UserNetwork 클래스를 초기화해줍니다

let session = URLSessionWrapper() // URLSession을 사용하는 세션 구현체
let networkManager = NetworkManager(session: session) // NetworkManager를 구성
let userNetwork = UserNetwork(manager: networkManager) // UserNetwork 초기화

 

 

 

 

 

그리고 userNetwork 의 fetchUsers 메소드를 사용하여 api를 호출합니다.

Task {
    let query = "john"
    let page = 1

    let result = await userNetwork.fetchUsers(query: query, page: page)
    switch result {
    case .success(let users):
        print("검색된 사용자 목록: \(users)")
    case .failure(let error):
        print("에러 발생: \(error)")
    }
}

 

 

 

 

 

그 다음은 테스트 코드입니다.

 

 

 

 

 

Session Protocol을 채택하는 MockSession을 생성해주고

import Foundation

public class MockSession: SessionProtocol {
    private let mockData: Data
    private let mockResponse: URLResponse

    public init(mockData: Data, mockResponse: URLResponse) {
        self.mockData = mockData
        self.mockResponse = mockResponse
    }

    public func performRequest(_ url: URLRequest) async throws -> (Data, URLResponse) {
        return (mockData, mockResponse)
    }
}

 

mockData, mockResponse를 return하는 performRequest를 작성합니다.

 

 

 

 

 

그리고 테스트에서 MockSession을 사용해 네트워크 요청을 시뮬레이션합니다.

import XCTest

final class UserNetworkTests: XCTestCase {
    func testFetchUsersSuccess() async {
        // Mock 데이터 설정
        let mockUserData = """
        [
            {"id": 1, "login": "user1"},
            {"id": 2, "login": "user2"}
        ]
        """.data(using: .utf8)!
        let mockResponse = HTTPURLResponse(url: URL(string: "https://api.github.com")!,
                                           statusCode: 200,
                                           httpVersion: nil,
                                           headerFields: nil)!

        // MockSession 생성
        let mockSession = MockSession(mockData: mockUserData, mockResponse: mockResponse)
        let networkManager = NetworkManager(session: mockSession)
        let userNetwork = UserNetwork(manager: networkManager)

        // 테스트 실행
        let result = await userNetwork.fetchUsers(query: "test", page: 1)
        switch result {
        case .success(let users):
            XCTAssertEqual(users.count, 2)
            XCTAssertEqual(users.first?.login, "user1")
        case .failure(let error):
            XCTFail("Test failed with error: \(error)")
        }
    }

    func testFetchUsersFailure() async {
        // Mock 데이터 설정
        let mockResponse = HTTPURLResponse(url: URL(string: "https://api.github.com")!,
                                           statusCode: 500,
                                           httpVersion: nil,
                                           headerFields: nil)!

        // MockSession 생성
        let mockSession = MockSession(mockData: Data(), mockResponse: mockResponse)
        let networkManager = NetworkManager(session: mockSession)
        let userNetwork = UserNetwork(manager: networkManager)

        // 테스트 실행
        let result = await userNetwork.fetchUsers(query: "test", page: 1)
        switch result {
        case .success:
            XCTFail("Test should have failed")
        case .failure(let error):
            XCTAssertEqual(error, .serverError(500))
        }
    }
}

 

 

 

Clean Architecture 기반하여 네트워크 추상화 그리고 테스트 까지 작성하였습니다.

감사합니다:)