Networking 1

Module 1 of 11 0%

Networking 1

URLSession is the foundation of networking in iOS development, it provides a powerful and flexible API for making HTTP requests and handling responses.

URLSession follows a hierarchical architecture with several key components:

URLSession: The core class that coordinates data transfer tasks
URLSessionConfiguration: Defines behaviour and policies for the session
URLSessionTask: Represents a specific data transfer operation
URLRequest: Encapsulate the request details (URL, headers, method, body)
URLResponse/HTTPURLResponse: Contains metadata about the server’s response

Session Configuration Types

// Default configuration with persistent cookies, cache, and credentials storage
let defaultSession = URLSession(configuration: .default)

// Ephemeral sessions store no data to disk
let ephemeralSession = URLSession(configuration: .ephemeral)

// Background sessions can continue transfers when app is suspended
let backgroundSession = URLSession(configuration: .background(withIdentifier: "some.identifier"))

// Custom configuration
let config = URLSessionConfiguration.default
config.timeoutIntervalForRequest = 30
config.httpMaximumConnectionsPerHost = 5
config.httpShouldUsePipelining = true
let customSession = URLSession(configuration: config)

Task Types

URLSession offers several task types for different networking needs:

Data task: Returns data directly to memory
Download task: Downloads files to disk and supports background downloads
Upload task: Uploads data or files and supports background uploads
WebSocket task: Establishes and maintains WebSocket connections

This is an example of basic data task:

let url = URL(string: "https://api.example.com/data")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
	// Handle error
	if let error = error {
		print("Error: \(error.localizedDescription)")
		return
	}

	// Check HTTP response
	guard let httpResponse = response as? HTTPURLResponse,
		(200...299).contains(httpResponse.statusCode) else {
		print("Invalid response")
		return
	}

	// Process data
	if let data = data {
		do {
			let json = try JSONSerialization.jsonObject(with: data)
			print("Received JSON: \(json))
		} catch {
			print("JSON error: \(error.localizedDescription)")
		}
	}
}
task.resume() // Must call resume() to start the task

Building URLRequests

var request = URLRequest(url: URL(string: "https://api.example.com/users")!)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization")

// Adding JSON body
let user = ["name": "John Doe", "email": "john@example.com"]
request.httpBody = try? JSONSerialization.data(withJSONObject: user)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
	// Handle response
}
task.resume()

REST Basics

REST (Representational State Transfer) is an architectural style for designing networked applications. REST APIs are commonly used for client-server communication, with servers exposing endpoints that the client apps can interact with.

Key REST principles:

Statelessness: Each request contains all information needed to process it
Resource-based: Endpoints represent resources (e.g., /users, /products)
Standard HTTP methods: Operations mapped to HTTP verbs
Representation: Resources delivered in standard formats (typically JSON)

CRUD Operations

CRUD (Create, Read, Update, Delete) maps to REST API operations as follows:

Create (HTTP method POST)

func createUser(user: User) {
	var request = URLRequest(url: URL(string: "https://api.example.com/users")!)
	request.httpMethod = "POST"
	request.setValue("application/json", forHTTPHeaderField: "Content-Type")
	request.httpBody = try? JSONEncoder().encode(user)

	URLSession.shared.dataTask(with: request) { data, response, error in
		// Handle response
	}.resume()
}

Read (HTTP method GET)

func fetchUsers() {
	var request = URLRequest(url: URL(string: "https://api.example.com/users")!)
	// GET is the default method

	URLSession.shared.dataTask(with: request) { data, response, error in
		guard let data = data else { return }
		let users = try? JSONDecoder().decode[User].self, from: data)
		// Update UI with users
	}.resume()
}

Update (HTTP method PUT/PATCH)

func updateUser(id: String, updates: UserUpdates) {
	var request = URLRequest(url: URL(string: "https://api.example.com/users/\(id)")!)
	request.httpMethod = "PUT" // or "PATCH" for partial updates
	request.setValue("application/json", forHTTPHeaderField: "Content-Type")
	request.httpBody = try? JSONEncoder().encode(updates)

	URLSession.shared.dataTask(with: request) { data, response, error in
		// Handle response
	}.resume()
}

Delete (HTTP method DELETE)

func deleteUser(id: String) {
	var request = URLRequest(url: URL(string: "https://api.example.com/users/\(id)")!)
	request.httpMethod = "DELETE"

	URLSession.shared.dataTask(with: request) { data, response, error in
		// Handle response
	}.resume()
}

In modern iOS development, these operations are often wrapped in networking layers, or integrated with Combine or async/await for more elegant implementations.

Parsing JSON with `Codable`

Codable is Swift’s built-in solution for converting between custom types and JSON data.

Defining Codable Models

struct User: Codable {
	let id: Int
	let name: String
	let email: String

	// For custom property names
	enum CodingKeys: String, CodingKey {
		case id
		case name
		case email = "email_address"
	}
}

Decode JSON to Models

// Assuming we have JSON data from an API response
func parseUsers(from data: Data) -> [User]? {
	do {
		return try JSONDecoder().decode([User].self, from: data)
	} catch {
		print("Decoding error: \(error)")
		return nil
	}
}

// Usage with URLSession
URLSession.shared.dataTask(with: request) { data, response, error in
		guard let data = data else { return }

		if let users = parseUsers(from: data) {
			DispatchQueue.main.async {
				self.users = users
				self.tableView.reloadData()
			}
		}
}.resume()

Encode Models to JSON

func createJSON(with user: User) -> Data? {
	do {
		return JSONEncoder().encode(user)
	} catch {
		print("Encoding error: \(error)")
		return nil
	}
}

// Usage when sending data to API
var request = URLRequest(url: URL(string: "https://api.example.com/users")!)
request.httpMethod = "POST"
request.httpBody = createJSON(with: user)
...

Codable handles most common JSON formats automatically and provides customisation options for more complex scenarios, making it the preferred way to work with JSON in Swift.

Mocking URLSession for Unit Testing

Mocking URLSession is essential for unit testing network requests without hitting actual endpoints. Here’s the steps you could use to approach that.

Create a protocol for URLSession

protocol URLSessionProtocol {
	func dataTask(with url: URL, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask
	func dataTask(with request: URLRequest, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask
}

// Make URLSession conform to this protocol
extension URLSession: URLSessionProtocol {}

Create a mock URLSessionDataTask

class MockURLSessionDataTask: URLSessionDataTask {
	private let closure: () -> Void

	init(closure: @escaping () -> Void) {
		self.closure = closure
		super.init()
	}

	override func resume() {
		closure()
	}
}

Implement a mock URLSession

class MockURLSession: URLSessionProtocol {
	var data: Data?
	var response: URLResponse?
	var error: Error?

	func dataTask(with url: URL, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask {
		return MockURLSessionDataTask {
			completionHandler(self.data, self.response, self.error
		}
	}

	func dataTask(with request: URLRequest, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask {
		return MockURLSessionDataTask {
			completionHandler(self.data, self.response, self.error
		}
	}
}

Use dependency injection in your network layer

class NetworkService {
	private let session: URLSessionProtocol

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

	func fetchData(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
		session.dataTask(with: url) { data, response, error in
			// Handle response and call completion
		}.resume()
	}
}

Write tests using the mock

func testFetchDataSuccess() {
	// Arrange
	let url = URL(string: "https://example.com")!
	let mockSession = MockURLSession()
	let mockData = "{\"name\":\"John\"}".data(using: .utf8)
	let mockResponse = HTTPURLResponse(url: url,
																		 statusCode: 200,
																		 httpVersion: nil,
																		 headerFields: nil)

	mockSession.data = mockData
	mockSession.response = mockResponse
	mockSession.error = nil

	let service = NetworkService(session: mockSession)
	let expectation = XCTestExpectation(description: "Fetch data")

	networkService.fetchData(from: url) {result in
		switch result {
		case .success(let data):
			XCTAssertEqual(data, mockData)
		case .failure:
			XCTFail("Should not fail")
		}
		expectation.fulfill()
	}

	wait(for: [expectation], timeout: 1.0)
}

This approach allows you to test your networking code with full control over the responses without making actual network calls, making your tests faster and more predictable.

iOS Roadmap

Networking 1

Session Configuration Types

Task Types

Building URLRequests

REST Basics

CRUD Operations

Parsing JSON with Codable

Defining Codable Models

Decode JSON to Models

Encode Models to JSON

Mocking URLSession for Unit Testing

Parsing JSON with `Codable`