UI coding and take-homes

UsersApp/
  App/
    UsersApp.swift
  Models/
    User.swift
  Services/
    UserService.swift
  Features/
    UserList/
      UserListView.swift
      UserListViewModel.swift
    UserDetail/
      UserDetailView.swift
UsersAppTests/
  UserListViewModelTests.swift
README.md

struct User: Decodable, Identifiable, Equatable, Sendable {
    let id: Int
    let name: String
    let email: String
}

protocol UserService: Sendable {
    func fetchUsers() async throws -> [User]
}

struct LiveUserService: UserService {
    let url: URL

    func fetchUsers() async throws -> [User] {
        let (data, response) = try await URLSession.shared.data(from: url)
        guard let http = response as? HTTPURLResponse,
              (200..<300).contains(http.statusCode) else {
            throw URLError(.badServerResponse)
        }
        return try JSONDecoder().decode([User].self, from: data)
    }
}

@MainActor
@Observable
final class UserListViewModel {
    enum LoadState: Equatable {
        case loading
        case loaded([User])
        case empty
        case failed(String)
    }

    private(set) var state: LoadState = .loading
    private let service: UserService

    init(service: UserService) {
        self.service = service
    }

    func load() async {
        state = .loading
        do {
            let users = try await service.fetchUsers()
            state = users.isEmpty ? .empty : .loaded(users)
        } catch {
            state = .failed("Could not load users. Please try again.")
        }
    }
}

import SwiftUI

struct UserListView: View {
    @State private var viewModel: UserListViewModel

    init(viewModel: UserListViewModel) {
        _viewModel = State(initialValue: viewModel)
    }

    var body: some View {
        content
            .navigationTitle("Users")
            .task { await viewModel.load() }
    }

    @ViewBuilder
    private var content: some View {
        switch viewModel.state {
        case .loading:
            ProgressView("Loading…")
        case .loaded(let users):
            List(users) { user in
                NavigationLink(value: user.id) {
                    VStack(alignment: .leading) {
                        Text(user.name).font(.headline)
                        Text(user.email)
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                }
            }
            .refreshable { await viewModel.load() }
        case .empty:
            ContentUnavailableView("No users yet", systemImage: "person.2")
        case .failed(let message):
            ContentUnavailableView {
                Label("Something went wrong", systemImage: "wifi.exclamationmark")
            } description: {
                Text(message)
            } actions: {
                Button("Try again") {
                    Task { await viewModel.load() }
                }
            }
        }
    }
}

import Testing
@testable import UsersApp

struct FakeUserService: UserService {
    let result: Result<[User], any Error>

    func fetchUsers() async throws -> [User] {
        try result.get()
    }
}

@MainActor
struct UserListViewModelTests {
    @Test func showsUsersAfterLoading() async {
        let users = [User(id: 1, name: "Ana", email: "ana@example.com")]
        let viewModel = UserListViewModel(service: FakeUserService(result: .success(users)))

        await viewModel.load()

        #expect(viewModel.state == .loaded(users))
    }

    @Test func showsEmptyStateForEmptyList() async {
        let viewModel = UserListViewModel(service: FakeUserService(result: .success([])))

        await viewModel.load()

        #expect(viewModel.state == .empty)
    }

    @Test func showsErrorWhenRequestFails() async {
        let viewModel = UserListViewModel(
            service: FakeUserService(result: .failure(URLError(.notConnectedToInternet)))
        )

        await viewModel.load()

        guard case .failed = viewModel.state else {
            Issue.record("Expected the failed state, got \(viewModel.state)")
            return
        }
    }
}

# Users App

## How to run
Open UsersApp.xcodeproj in Xcode 26 or later. Run the UsersApp scheme. No setup needed.

## What it does
- Loads users from the API and shows them in a list.
- Tap a user to see details.
- Pull to refresh. Loading, empty and error states.

## Architecture
MVVM. Views are SwiftUI. View models are @MainActor @Observable classes.
Networking is behind a UserService protocol, so view models are easy to test.

## Decisions and trade-offs
- No third-party libraries, to keep the project small.
- No disk cache. With more time I would cache the last response for offline use.

## Tests
UserListViewModelTests covers the loaded, empty and error states.

## With more time I would
- Add pagination.
- Add snapshot tests for the main screens.
- Improve VoiceOver labels on the detail screen.

## Time spent
About 5 hours.

// TODO (live round plan):
// 1. Model + fake data in the list   <- done
// 2. Real networking
// 3. Error and empty states
// 4. Detail screen
// 5. One view model test