Swift Academy · Aula

Simulação de Dependências em Testes

Substitua implementações reais por substitutos de teste.

Simulação de Dependências em Testes é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Simulando Dependências em Testes

Um objeto simulado é uma implementação falsa de uma dependência, usada em testes. Como injetamos protocolos, podemos fornecer um objeto simulado em vez do colaborador real.

Um Protocolo para Simular

Comece com um protocolo que descreva a dependência. O tipo real e o objeto simulado devem estar em conformidade com ele.

protocol UserStore {
    func name(for id: Int) -> String
}
struct RealStore: UserStore {
    func name(for id: Int) -> String { "User-\(id)" }
}
print(RealStore().name(for: 5))

Escrevendo um Objeto Simulado

Um objeto simulado está em conformidade com o protocolo, mas retorna valores predefinidos, evitando o acesso real à rede ou ao disco.

protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore {
    func name(for id: Int) -> String { "Mock" }
}
print(MockStore().name(for: 99))

Injetando o Objeto Simulado

Passe o objeto simulado ao sistema em teste por meio de seu inicializador. O código em teste não consegue perceber a diferença.

protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore { func name(for id: Int) -> String { "Mock" } }
struct Profile {
    let store: UserStore
    func title(_ id: Int) -> String { "Hello, " + store.name(for: id) }
}
print(Profile(store: MockStore()).title(1))

Registrando Chamadas

Um objeto simulado pode registrar como foi usado, para que um teste verifique se a dependência foi chamada corretamente.

protocol Analytics { func track(_ e: String) }
class SpyAnalytics: Analytics {
    var events: [String] = []
    func track(_ e: String) { events.append(e) }
}
let spy = SpyAnalytics()
spy.track("open")
spy.track("buy")
print(spy.events)

Verificando o Comportamento

Depois de executar o código, verifique os dados registrados. Aqui, confirmamos que o evento correto foi disparado.

protocol Analytics { func track(_ e: String) }
class Spy: Analytics { var last = ""; func track(_ e: String) { last = e } }
struct Checkout { let analytics: Analytics; func pay() { analytics.track("paid") } }
let spy = Spy()
Checkout(analytics: spy).pay()
print(spy.last == "paid")

Definindo Valores de Retorno

Um substituto retorna valores predefinidos, para que você possa testar como seu código reage a entradas específicas.

protocol Clock { func hour() -> Int }
struct StubClock: Clock { let value: Int; func hour() -> Int { value } }
struct Greeter { let clock: Clock; func greet() -> String { clock.hour() < 12 ? "AM" : "PM" } }
print(Greeter(clock: StubClock(value: 9)).greet())
print(Greeter(clock: StubClock(value: 18)).greet())

Simulando uma Falha

Objetos simulados podem reproduzir condições de erro difíceis de provocar com dependências reais, aumentando a cobertura dos testes.

protocol Loader { func load() -> Int? }
struct FailingLoader: Loader { func load() -> Int? { nil } }
struct VM { let loader: Loader; func status() -> String { loader.load() == nil ? "error" : "ok" } }
print(VM(loader: FailingLoader()).status())

Testes Determinísticos

Como os objetos simulados retornam valores fixos, os testes são rápidos e determinísticos, sem instabilidade causada por serviços reais.

protocol Random { func next() -> Int }
struct FixedRandom: Random { func next() -> Int { 42 } }
struct Game { let rng: Random; func roll() -> Int { rng.next() } }
print(Game(rng: FixedRandom()).roll())

Nenhum Framework de Testes Aqui

Em um projeto real, essas verificações ficam nas asserções do XCTest. O padrão de injeção é idêntico; apenas a sintaxe das asserções muda.

protocol Calc { func add(_ a: Int, _ b: Int) -> Int }
struct RealCalc: Calc { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct MockCalc: Calc { func add(_ a: Int, _ b: Int) -> Int { 0 } }
print(RealCalc().add(2, 2))
print(MockCalc().add(2, 2))

O Ciclo Completo

Defina o protocolo, escreva implementações reais e simuladas em conformidade, injete o objeto simulado, execute o código e verifique o resultado. A DI torna cada etapa possível.

protocol Repo { func count() -> Int }
struct MockRepo: Repo { func count() -> Int { 3 } }
struct Stats { let repo: Repo; func total() -> Int { repo.count() * 2 } }
print(Stats(repo: MockRepo()).total())

Verificação Rápida

O que torna possível simular uma dependência nessa abordagem?

Recapitulação

Um objeto simulado está em conformidade com o protocolo injetado e retorna valores predefinidos, registra chamadas ou simula falhas. Injetá-lo produz testes rápidos e determinísticos. O ciclo é: definir o protocolo, escrever implementações reais e simuladas em conformidade, injetar, executar e verificar. Isso conclui o curso de DI.

Perguntas Frequentes

A aula “Simulação de Dependências em Testes” é grátis?

Sim — o texto completo de “Simulação de Dependências em Testes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Simulação de Dependências em Testes”?

Substitua implementações reais por substitutos de teste. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Simulação de Dependências em Testes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy