iOS 앱 아키텍처

MVVM (Model-View-ViewModel)
iOS에서 가장 많이 사용되는 패턴이야. 특히 SwiftUI와 Combine을 사용하면 정말 깔끔하게 구현할 수 있어!

// Model
struct User: Codable, Identifiable {
    let id: String
    var name: String
    var email: String
}

// ViewModel
class UserListViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let repository: UserRepository
    
    init(repository: UserRepository = UserRepository()) {
        self.repository = repository
    }
    
    func loadUsers() async {
        isLoading = true
        do {
            users = try await repository.fetchUsers()
            isLoading = false
        } catch {
            errorMessage = error.localizedDescription
            isLoading = false
        }
    }
}

// View
struct UserListView: View {
    @StateObject private var viewModel = UserListViewModel()
    
    var body: some View {
        NavigationView {
            Group {
                if viewModel.isLoading {
                    ProgressView()
                } else if let error = viewModel.errorMessage {
                    Text("에러: \(error)")
                } else {
                    List(viewModel.users) { user in
                        UserRow(user: user)
                    }
                }
            }
            .navigationTitle("사용자")
            .task {
                await viewModel.loadUsers()
            }
        }
    }
}

프로젝트 구조:

MyApp/
├── App/
│   └── MyApp.swift
├── Models/
│   ├── User.swift
│   └── Post.swift
├── ViewModels/
│   ├── UserListViewModel.swift
│   └── UserDetailViewModel.swift
├── Views/
│   ├── UserListView.swift
│   └── UserDetailView.swift
├── Services/
│   ├── NetworkService.swift
│   └── DatabaseService.swift
└── Utilities/
    └── Extensions.swift

Android 앱 아키텍처

MVVM + Clean Architecture
Android에서는 Jetpack 라이브러리와 함께 MVVM을 많이 사용해. Hilt로 의존성 주입까지 하면 완벽해!

// Model
data class User(
    val id: String,
    val name: String,
    val email: String
)

// Repository
class UserRepository @Inject constructor(
    private val api: ApiService,
    private val dao: UserDao
) {
    suspend fun getUsers(): Result<List<User>> {
        return try {
            val users = api.getUsers()
            dao.insertAll(users)
            Result.success(users)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

// ViewModel
@HiltViewModel
class UserListViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    
    init {
        loadUsers()
    }
    
    private fun loadUsers() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            repository.getUsers()
                .onSuccess { users ->
                    _uiState.value = UiState.Success(users)
                }
                .onFailure { error ->
                    _uiState.value = UiState.Error(error.message ?: "Unknown error")
                }
        }
    }
}

// UI State
sealed class UiState {
    object Loading : UiState()
    data class Success(val users: List<User>) : UiState()
    data class Error(val message: String) : UiState()
}

// Composable
@Composable
fun UserListScreen(viewModel: UserListViewModel = hiltViewModel()) {
    val uiState by viewModel.uiState.collectAsState()
    
    Scaffold(
        topBar = { TopAppBar(title = { Text("사용자") }) }
    ) { padding ->
        when (val state = uiState) {
            is UiState.Loading -> {
                Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                    CircularProgressIndicator()
                }
            }
            is UiState.Success -> {
                LazyColumn(Modifier.padding(padding)) {
                    items(state.users) { user ->
                        UserListItem(user = user)
                    }
                }
            }
            is UiState.Error -> {
                Text("에러: ${state.message}")
            }
        }
    }
}

프로젝트 구조:

app/
├── src/main/
│   ├── java/com/example/myapp/
│   │   ├── data/
│   │   │   ├── model/
│   │   │   ├── repository/
│   │   │   └── remote/
│   │   ├── domain/
│   │   │   └── usecase/
│   │   ├── presentation/
│   │   │   ├── userlist/
│   │   │   │   ├── UserListViewModel.kt
│   │   │   │   └── UserListScreen.kt
│   │   │   └── userdetail/
│   │   └── di/
│   │       └── AppModule.kt
│   └── res/
│       ├── values/
│       └── drawable/

iOS 테스트 프레임워크

XCTest
Apple의 공식 테스트 프레임워크야. Unit Test와 UI Test를 모두 지원해.

import XCTest
@testable import MyApp

class UserViewModelTests: XCTestCase {
    var viewModel: UserViewModel!
    var mockRepository: MockUserRepository!
    
    override func setUp() {
        super.setUp()
        mockRepository = MockUserRepository()
        viewModel = UserViewModel(repository: mockRepository)
    }
    
    func testLoadUsers_Success() async {
        // Given
        let expectedUsers = [
            User(id: "1", name: "김개발", email: "kim@dev.com")
        ]
        mockRepository.usersToReturn = expectedUsers
        
        // When
        await viewModel.loadUsers()
        
        // Then
        XCTAssertEqual(viewModel.users.count, 1)
        XCTAssertEqual(viewModel.users.first?.name, "김개발")
        XCTAssertFalse(viewModel.isLoading)
    }
    
    func testLoadUsers_Failure() async {
        // Given
        mockRepository.shouldFail = true
        
        // When
        await viewModel.loadUsers()
        
        // Then
        XCTAssertTrue(viewModel.users.isEmpty)
        XCTAssertNotNil(viewModel.errorMessage)
    }
}

Quick/Nimble
BDD(Behavior-Driven Development) 스타일의 테스트를 작성할 수 있는 서드파티 라이브러리야.

UI Testing
실제 사용자 인터랙션을 시뮬레이션해서 테스트할 수 있어.

Android 테스트 프레임워크

JUnit + Mockito
Android의 표준 테스트 조합이야.

import org.junit.Test
import org.junit.Before
import org.mockito.Mock
import org.mockito.Mockito.*
import kotlinx.coroutines.test.runTest

class UserViewModelTest {
    @Mock
    private lateinit var repository: UserRepository
    
    private lateinit var viewModel: UserViewModel
    
    @Before
    fun setup() {
        MockitoAnnotations.openMocks(this)
        viewModel = UserViewModel(repository)
    }
    
    @Test
    fun `loadUsers success updates state correctly`() = runTest {
        // Given
        val expectedUsers = listOf(
            User("1", "김개발", "kim@dev.com")
        )
        `when`(repository.getUsers()).thenReturn(Result.success(expectedUsers))
        
        // When
        viewModel.loadUsers()
        
        // Then
        val state = viewModel.uiState.value
        assert(state is UiState.Success)
        assertEquals(expectedUsers, (state as UiState.Success).users)
    }
    
    @Test
    fun `loadUsers failure updates state with error`() = runTest {
        // Given
        val errorMessage = "Network error"
        `when`(repository.getUsers()).thenReturn(Result.failure(Exception(errorMessage)))
        
        // When
        viewModel.loadUsers()
        
        // Then
        val state = viewModel.uiState.value
        assert(state is UiState.Error)
        assertEquals(errorMessage, (state as UiState.Error).message)
    }
}

Espresso
UI 테스트를 위한 프레임워크야. 실제 사용자 동작을 시뮬레이션해.

Robolectric
에뮬레이터 없이 JVM에서 Android 테스트를 실행할 수 있어서 빠르게 테스트할 수 있어.