Dependências e pacotes

export interface EnviadorDeEmail {
  enviar(para: string, assunto: string, corpo: string): Promise<void>;
}

// A única parte do código que conhece o SDK do provedor
export class EnviadorDoProvedor implements EnviadorDeEmail {
  private readonly cliente: ClienteDoProvedor;

  constructor(cliente: ClienteDoProvedor) {
    this.cliente = cliente;
  }

  async enviar(para: string, assunto: string, corpo: string) {
    await this.cliente.messages.send({ to: para, subject: assunto, text: corpo });
  }
}

// Para testes: guarda os e-mails em vez de enviar
export class EnviadorFalso implements EnviadorDeEmail {
  readonly enviados: { para: string; assunto: string }[] = [];

  async enviar(para: string, assunto: string) {
    this.enviados.push({ para, assunto });
  }
}

from dataclasses import dataclass, field
from typing import Protocol


class EnviadorDeEmail(Protocol):
    def enviar(self, para: str, assunto: str, corpo: str) -> None: ...


class EnviadorDoProvedor:
    """A única parte do código que conhece o SDK do provedor."""

    def __init__(self, cliente):
        self.cliente = cliente

    def enviar(self, para: str, assunto: str, corpo: str) -> None:
        self.cliente.messages.send(to=para, subject=assunto, text=corpo)


@dataclass
class EnviadorFalso:
    """Para testes: guarda os e-mails em vez de enviar."""

    enviados: list[tuple[str, str]] = field(default_factory=list)

    def enviar(self, para: str, assunto: str, corpo: str) -> None:
        self.enviados.append((para, assunto))

package email

import "context"

type Enviador interface {
	Enviar(ctx context.Context, para, assunto, corpo string) error
}

// EnviadorDoProvedor é a única parte do código que conhece o SDK.
type EnviadorDoProvedor struct {
	Cliente ClienteDoProvedor
}

func (e EnviadorDoProvedor) Enviar(ctx context.Context, para, assunto, corpo string) error {
	return e.Cliente.Send(ctx, Mensagem{To: para, Subject: assunto, Text: corpo})
}

// EnviadorFalso guarda os e-mails, para testes.
type EnviadorFalso struct {
	Enviados []string
}

func (e *EnviadorFalso) Enviar(_ context.Context, para, assunto, _ string) error {
	e.Enviados = append(e.Enviados, para+": "+assunto)
	return nil
}

import java.util.ArrayList;
import java.util.List;

public interface EnviadorDeEmail {
    void enviar(String para, String assunto, String corpo);
}

// A única parte do código que conhece o SDK do provedor
final class EnviadorDoProvedor implements EnviadorDeEmail {
    private final ClienteDoProvedor cliente;

    EnviadorDoProvedor(ClienteDoProvedor cliente) {
        this.cliente = cliente;
    }

    @Override
    public void enviar(String para, String assunto, String corpo) {
        cliente.messages().send(para, assunto, corpo);
    }
}

// Para testes: guarda os e-mails em vez de enviar
final class EnviadorFalso implements EnviadorDeEmail {
    final List<String> enviados = new ArrayList<>();

    @Override
    public void enviar(String para, String assunto, String corpo) {
        enviados.add(para + ": " + assunto);
    }
}

public interface IEnviadorDeEmail
{
    Task Enviar(string para, string assunto, string corpo);
}

// A única parte do código que conhece o SDK do provedor
public sealed class EnviadorDoProvedor(ClienteDoProvedor cliente) : IEnviadorDeEmail
{
    public Task Enviar(string para, string assunto, string corpo) =>
        cliente.Messages.SendAsync(para, assunto, corpo);
}

// Para testes: guarda os e-mails em vez de enviar
public sealed class EnviadorFalso : IEnviadorDeEmail
{
    public List<string> Enviados { get; } = [];

    public Task Enviar(string para, string assunto, string corpo)
    {
        Enviados.Add($"{para}: {assunto}");
        return Task.CompletedTask;
    }
}