private func bindPlan() {
    viewModel.$plan
        .receive(on: DispatchQueue.main)
        .sink { [weak self] _ in
            self?.tableView.reloadData()
        }
        .store(in: &cancellables)
}

private func configureTableView() {
    dataSource = UITableViewDiffableDataSource<Section, Plan>(tableView: tableView) { [unowned self] _, indexPath, _ in
        guard let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as? PlanTableViewCell else { return UITableViewCell() }
            
        let plan = viewModel.read(at: indexPath)
        cell.configureCell(with: plan)
            
        return cell
    }
}
    
private func createSnapshot(_ plans: [Plan]) {
    var snapshot = NSDiffableDataSourceSnapshot<Section, Plan>()
        
    snapshot.appendSections([.main])
    snapshot.appendItems(plans)
    dataSource?.apply(snapshot, animatingDifferences: true)
}

private func bindPlan() {
    viewModel.$plan
        .receive(on: DispatchQueue.main)
        .sink { [weak self] plans in
            self?.createSnapshot(plans)
        }
        .store(in: &cancellables)
}

struct Plan: Hashable {
    let id: UUID = UUID()
    var title: String
    var body: String
    var date: Date
    var state: State
}

private func delete(by id: UUID) {
    planList.removeAll { $0.id == id }
}

private func changeState(plan: Plan, state: State) {
    guard let index = self.planList.firstIndex(where: { $0.id == plan.id }) else { return }
        
    var plan = planList[index]
    plan.state = state
      
    update(plan)
}

func update(_ plan: Plan) {
    guard let index = self.planList.firstIndex(where: { $0.id == plan.id }) else { return }
    self.planList[index] = plan
}

import Foundation
import Combine

final class PlanManagerViewModel {
    @Published var planList: [Plan] = []
    private var cancellables = Set<AnyCancellable>()
    
    private let todoViewModel: PlanSubscriber
    private let doingViewModel: PlanSubscriber
    private let doneViewModel: PlanSubscriber
    
    init(todoViewModel: PlanSubscriber, doingViewModel: PlanSubscriber, doneViewModel: PlanSubscriber) {
        self.todoViewModel = todoViewModel
        self.doingViewModel = doingViewModel
        self.doneViewModel = doneViewModel
        setUpBindings()
    }
    ...
    
    private func bindDelete(subscriber: PlanSubscriber) {
        subscriber.deletePublisher
            .sink { [weak self] plan in
                self?.delete(by: plan.id)
            }
            .store(in: &cancellables)
    }
    
    private func bindChange(subscriber: PlanSubscriber) {
        subscriber.changePublisher
            .sink { [weak self] (plan, state) in
                self?.changeState(plan: plan, state: state)
            }
            .store(in: &cancellables)
    }
    
    private func delete(by id: UUID) {
        planList.removeAll { $0.id == id }
    }
    
    private func changeState(plan: Plan, state: State) {
        guard let index = self.planList.firstIndex(where: { $0.id == plan.id }) else { return }
        
        var plan = planList[index]
        plan.state = state
      
        update(plan)
    }
}

import Foundation
import Combine

final class MockPlanSubscriber: PlanSubscriber {
    var plans: [Plan]?
    var deletePublisher = PassthroughSubject<Plan, Never>()
    var changePublisher = PassthroughSubject<(Plan, State), Never>()

    func updatePlan(_ plans: [Plan]) {
        self.plans = plans
    }
}

import XCTest
@testable import ProjectManager

final class PlanManagerViewModelTests: XCTestCase {
    var sut: PlanManagerViewModel!
    var mockTodoPlanSubscriber: MockPlanSubscriber!
    var mockDoingPlanSubscriber: MockPlanSubscriber!
    var mockDonePlanSubscriber: MockPlanSubscriber!
    
    override func setUpWithError() throws {
        try super.setUpWithError()
        
        mockTodoPlanSubscriber = MockPlanSubscriber()
        mockDoingPlanSubscriber = MockPlanSubscriber()
        mockDonePlanSubscriber = MockPlanSubscriber()
        
        sut = PlanManagerViewModel(
            todoViewModel: mockTodoPlanSubscriber,
            doingViewModel: mockDoingPlanSubscriber,
            doneViewModel: mockDonePlanSubscriber
        )
    }
    
    override func tearDownWithError() throws {
        try super.tearDownWithError()
        
        sut = nil
    }
    ...
    func test_mockPlanSubscriber의_deletePublisher에값이들어오면_planList배열에서삭제된다() {
        // given
        let todoPlan = Plan(title: "산책", body: "강아지 산책시키기", date: Date(), state: .todo)
        let doingPlan = Plan(title: "집안일", body: "설거지, 빨래, 청소기돌리기", date: Date(), state: .doing)
        let donePlan = Plan(title: "공부", body: "MVC, MVP, MVVM 패턴 공부하기", date: Date(), state: .done)
        
        sut.create(todoPlan)
        sut.create(doingPlan)
        sut.create(donePlan)
        let oldPlans = sut.planList
        
        mockTodoPlanSubscriber.deletePublisher.send(todoPlan)
        mockDoingPlanSubscriber.deletePublisher.send(doingPlan)
        mockDonePlanSubscriber.deletePublisher.send(donePlan)
        
        // when
        let newPlans = sut.planList
        
        // then
        XCTAssertNotEqual(oldPlans, newPlans)
    }
}