Fetching Data with URLSession and Returning Result<Data, Error> in Swift

Desired outcome

Write a reusable function that performs a GET request with URLSession, validates the HTTP response, and delivers either the response data or an error through a Result value supplied to a completion handler.

Prerequisites

• Swift 5 or later (the Result type is part of the standard library).
• Xcode 11 or newer (provides the required SDK).
• Import Foundation to access URLSession and related types.
• The caller must supply a valid URL and be prepared to handle the completion on a background thread (the delegate queue of the session).

Focused procedure

1. Create a URLRequest from the supplied URL, optionally configuring timeout or cache policy.
2. Instantiate a data task with URLSession.shared.dataTask(with:request) and provide a completion handler that receives data, response, and error.
3. If the error parameter is non‑nil, forward it as .failure(error) and exit the handler.
4. Attempt to downcast response to HTTPURLResponse. If the cast fails or the status code is outside the range 200‑299, complete with .failure(URLError(.badServerResponse)).
5. Guard against a nil data payload; if missing, complete with the same .badServerResponse error.
6. When all checks succeed, call the completion with .success(data).
7. Finally, invoke task.resume() to start the request.

import Foundation

func fetchData(from url: URL,
               completion: @escaping (Result) -> Void) {
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.timeoutInterval = 30.0

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }

        guard let httpResponse = response as? HTTPURLResponse else {
            completion(.failure(URLError(.badServerResponse)))
            return
        }

        guard (200...299).contains(httpResponse.statusCode) else {
            completion(.failure(URLError(.badServerResponse)))
            return
        }

        guard let data = data else {
            completion(.failure(URLError(.badServerResponse)))
            return
        }

        completion(.success(data))
    }
    task.resume()
}

Expected checks and recovery options

• Status‑code validation: The helper treats any HTTP response outside 200‑299 as a failure; you may adjust the range to accept redirects or other success codes if your API requires it.
• Missing data: A nil data with a successful status code is still considered an error (.badServerResponse) because the contract expects a payload.
• Transient errors: Errors such as URLError.timedOut or .networkConnectionLost can be retried by re‑invoking fetchData after a short delay or with exponential back‑off.
• Fallback values: Before propagating a failure, you may attempt to read a cached response (e.g., from URLCache) and return that data as a .success if staleness is acceptable.
• Threading: The completion runs on URLSession’s internal delegate queue. If you need to update UI, dispatch to DispatchQueue.main inside the completion or at the call site.

Verification (no test execution claimed)

• Unit‑test approach: inject a mock URLSession (via dependency injection or protocol) that returns predefined Data or URLError instances; assert that the completion receives the matching Result case.
• Integration check: call the function against a known endpoint such as https://httpbin.org/get and verify that the Result is .success with non‑empty Data and a status code in the 200‑299 range.
• Error‑path check: disconnect the network or request an invalid host (e.g., https://nonexistent.invalid) and confirm that the completion yields a .failure whose error domain is URLError.