Separar domínio, persistência e interface

# aplicacao/portas.py
from typing import Protocol


class Catalogo(Protocol):
    # As operações necessárias serão definidas no próximo passo.
    ...


# aplicacao/cadastrar_item.py
from aplicacao.portas import Catalogo
from dominio.item import Item


def cadastrar_item(item: Item, catalogo: Catalogo) -> Item:
    # Consulta e inclusão pertencem a este fluxo de aplicação.
    # Não importe JsonCatalogo nem crie adaptadores aqui.
    return item


# adaptadores/repositorio_json.py
from aplicacao.portas import Catalogo


class CatalogoJson:
    # Implementará o comportamento esperado por Catalogo.
    ...

from dataclasses import dataclass


class TituloInvalidoError(ValueError):
    """O título não atende a uma regra do catálogo."""


@dataclass(frozen=True)
class ItemCatalogo:
    codigo: str
    titulo: str

    def __post_init__(self) -> None:
        if not self.titulo.strip():
            raise TituloInvalidoError(
                "Um item do catálogo precisa de título."
            )

from typing import Protocol

from dominio.item import Item


class FalhaDePersistencia(Exception):
    """Não foi possível executar uma operação exigida pelo contrato."""


class RepositorioDeItens(Protocol):
    def buscar_por_codigo(self, codigo: str) -> Item | None:
        """Retorna o item cadastrado ou None se o código estiver ausente.

        Não altera o catálogo.
        Pode levantar FalhaDePersistencia.
        """

    def adicionar(self, item: Item) -> None:
        """Inclui um item cujo código ainda não está cadastrado.

        Após retornar, uma busca pelo código do item deve encontrá-lo.
        Pode levantar FalhaDePersistencia.
        """

from dataclasses import dataclass


class TituloInvalido(ValueError):
    pass


class CodigoDuplicado(ValueError):
    pass


@dataclass(frozen=True)
class Item:
    codigo: str
    titulo: str

    def __post_init__(self) -> None:
        if not self.titulo.strip():
            raise TituloInvalido("O título não pode ser vazio.")

from typing import Protocol

from catalogo.dominio import Item


class RepositorioDeItens(Protocol):
    def buscar_por_codigo(self, codigo: str) -> Item | None:
        """Retorna o item encontrado ou None quando o código está ausente."""

    def adicionar(self, item: Item) -> None:
        """Inclui um item cujo código ainda não está cadastrado."""

from catalogo.contratos import RepositorioDeItens
from catalogo.dominio import CodigoDuplicado, Item


def cadastrar(
    codigo: str,
    titulo: str,
    repositorio: RepositorioDeItens,
) -> Item:
    item = Item(codigo=codigo, titulo=titulo)

    if repositorio.buscar_por_codigo(codigo) is not None:
        raise CodigoDuplicado(f"O código {codigo!r} já está cadastrado.")

    repositorio.adicionar(item)
    return item

from catalogo.dominio import Item


class RepositorioEmMemoria:
    def __init__(self) -> None:
        self._itens: dict[str, Item] = {}
        self.quantidade_de_gravacoes = 0

    def buscar_por_codigo(self, codigo: str) -> Item | None:
        return self._itens.get(codigo)

    def adicionar(self, item: Item) -> None:
        self._itens[item.codigo] = item
        self.quantidade_de_gravacoes += 1

import pytest

from catalogo.cadastro import cadastrar
from catalogo.dominio import CodigoDuplicado, TituloInvalido
from catalogo.memoria import RepositorioEmMemoria


def test_cadastra_item_e_o_torna_consultavel() -> None:
    repositorio = RepositorioEmMemoria()

    resultado = cadastrar("A1", "Python avançado", repositorio)

    assert resultado.codigo == "A1"
    assert repositorio.buscar_por_codigo("A1") == resultado
    assert repositorio.quantidade_de_gravacoes == 1


def test_titulo_invalido_nao_grava() -> None:
    repositorio = RepositorioEmMemoria()

    with pytest.raises(TituloInvalido):
        cadastrar("A1", "   ", repositorio)

    assert repositorio.buscar_por_codigo("A1") is None
    assert repositorio.quantidade_de_gravacoes == 0


def test_codigo_duplicado_nao_grava_novamente() -> None:
    repositorio = RepositorioEmMemoria()
    cadastrar("A1", "Primeiro título", repositorio)

    with pytest.raises(CodigoDuplicado):
        cadastrar("A1", "Outro título", repositorio)

    assert repositorio.buscar_por_codigo("A1").titulo == "Primeiro título"
    assert repositorio.quantidade_de_gravacoes == 1

from __future__ import annotations

import json
from pathlib import Path

from catalogo.aplicacao.portas import FalhaPersistencia
from catalogo.dominio.item import Item


class RepositorioJson:
    def __init__(self, caminho: Path) -> None:
        self._caminho = caminho

    def buscar_por_codigo(self, codigo: str) -> Item | None:
        for item in self._carregar_itens():
            if item.codigo == codigo:
                return item
        return None

    def adicionar(self, item: Item) -> None:
        itens = self._carregar_itens()
        registros = [
            {"codigo": existente.codigo, "titulo": existente.titulo}
            for existente in itens
        ]
        registros.append({"codigo": item.codigo, "titulo": item.titulo})

        try:
            conteudo = json.dumps(registros, ensure_ascii=False, indent=2)
            self._caminho.write_text(conteudo, encoding="utf-8")
        except OSError as exc:
            raise FalhaPersistencia("não foi possível gravar o catálogo") from exc

    def _carregar_itens(self) -> list[Item]:
        try:
            conteudo = self._caminho.read_text(encoding="utf-8")
        except FileNotFoundError:
            return []
        except OSError as exc:
            raise FalhaPersistencia("não foi possível ler o catálogo") from exc

        try:
            registros = json.loads(conteudo)
            if not isinstance(registros, list):
                raise TypeError("a raiz do JSON deve ser uma lista")

            return [
                Item(codigo=registro["codigo"], titulo=registro["titulo"])
                for registro in registros
                if isinstance(registro, dict)
            ]
        except (json.JSONDecodeError, KeyError, TypeError, ValueError) as exc:
            raise FalhaPersistencia("dados do catálogo são inválidos") from exc

import pytest

from catalogo.adaptadores.repositorio_json import RepositorioJson
from catalogo.aplicacao.portas import FalhaPersistencia
from catalogo.dominio.item import Item


def test_arquivo_ausente_representa_catalogo_vazio(tmp_path) -> None:
    repositorio = RepositorioJson(tmp_path / "catalogo.json")

    assert repositorio.buscar_por_codigo("PY-01") is None


def test_item_gravado_e_recuperado_por_nova_instancia(tmp_path) -> None:
    caminho = tmp_path / "catalogo.json"
    primeira_instancia = RepositorioJson(caminho)
    primeira_instancia.adicionar(Item(codigo="PY-01", titulo="Python avançado"))

    segunda_instancia = RepositorioJson(caminho)

    assert segunda_instancia.buscar_por_codigo("PY-01") == Item(
        codigo="PY-01",
        titulo="Python avançado",
    )


def test_json_invalido_e_falha_de_persistencia(tmp_path) -> None:
    caminho = tmp_path / "catalogo.json"
    caminho.write_text("{ nao e json }", encoding="utf-8")
    repositorio = RepositorioJson(caminho)

    with pytest.raises(FalhaPersistencia) as erro:
        repositorio.buscar_por_codigo("PY-01")

    assert isinstance(erro.value.__cause__, Exception)

from collections.abc import Callable
from catalogo.dominio.item import Item


def cadastrar_e_mostrar(
    cadastrar: Callable[[object, str, str], Item],
    repositorio: object,
    codigo: str,
    titulo: str,
) -> None:
    item = cadastrar(repositorio, codigo, titulo)
    print(f"Item cadastrado: {item.codigo} — {item.titulo}")

from pathlib import Path

from catalogo.adaptadores.repositorio_json import RepositorioJson
from catalogo.aplicacao.cadastrar_item import cadastrar_item
from catalogo.interface_terminal import cadastrar_e_mostrar


def executar_demonstracao() -> None:
    arquivo = Path("catalogo.json")
    repositorio = RepositorioJson(arquivo)

    cadastrar_e_mostrar(
        cadastrar_item,
        repositorio,
        codigo="LIV-001",
        titulo="Arquitetura Python",
    )


if __name__ == "__main__":
    executar_demonstracao()

from catalogo.adaptadores.repositorio_memoria import RepositorioMemoria


def executar_demonstracao_em_memoria() -> None:
    repositorio = RepositorioMemoria()

    cadastrar_e_mostrar(
        cadastrar_item,
        repositorio,
        codigo="LIV-001",
        titulo="Arquitetura Python",
    )

# catalogo/dominio.py
from dataclasses import dataclass


class ItemInvalido(ValueError):
    pass


@dataclass(frozen=True, slots=True)
class Item:
    codigo: str
    titulo: str

    def __post_init__(self) -> None:
        if not self.titulo.strip():
            raise ItemInvalido("o título não pode ser vazio")


# catalogo/aplicacao.py
from typing import Protocol

from catalogo.dominio import Item


class FalhaDePersistencia(RuntimeError):
    pass


class CodigoDuplicado(ValueError):
    pass


class RepositorioDeItens(Protocol):
    def buscar_por_codigo(self, codigo: str) -> Item | None: ...

    def adicionar(self, item: Item) -> None: ...


class CadastrarItem:
    def __init__(self, repositorio: RepositorioDeItens) -> None:
        self._repositorio = repositorio

    def executar(self, codigo: str, titulo: str) -> Item:
        item = Item(codigo=codigo, titulo=titulo)
        if self._repositorio.buscar_por_codigo(item.codigo) is not None:
            raise CodigoDuplicado(f"código já cadastrado: {item.codigo}")
        self._repositorio.adicionar(item)
        return item


# catalogo/adaptadores.py
import json
from pathlib import Path

from catalogo.aplicacao import FalhaDePersistencia
from catalogo.dominio import Item


class RepositorioEmMemoria:
    def __init__(self) -> None:
        self._itens: dict[str, Item] = {}
        self.gravacoes = 0

    def buscar_por_codigo(self, codigo: str) -> Item | None:
        return self._itens.get(codigo)

    def adicionar(self, item: Item) -> None:
        self._itens[item.codigo] = item
        self.gravacoes += 1


class RepositorioJson:
    def __init__(self, caminho: Path) -> None:
        self._caminho = caminho

    def _carregar(self) -> list[Item]:
        if not self._caminho.exists():
            return []
        try:
            bruto = json.loads(self._caminho.read_text(encoding="utf-8"))
            if not isinstance(bruto, list):
                raise ValueError("a raiz JSON deve ser uma lista")
            return [Item(registro["codigo"], registro["titulo"]) for registro in bruto]
        except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError) as erro:
            raise FalhaDePersistencia("não foi possível carregar o catálogo") from erro

    def _salvar(self, itens: list[Item]) -> None:
        registros = [{"codigo": item.codigo, "titulo": item.titulo} for item in itens]
        try:
            self._caminho.write_text(
                json.dumps(registros, ensure_ascii=False, indent=2),
                encoding="utf-8",
            )
        except OSError as erro:
            raise FalhaDePersistencia("não foi possível gravar o catálogo") from erro

    def buscar_por_codigo(self, codigo: str) -> Item | None:
        return next((item for item in self._carregar() if item.codigo == codigo), None)

    def adicionar(self, item: Item) -> None:
        itens = self._carregar()
        itens.append(item)
        self._salvar(itens)


# catalogo/interface.py
from catalogo.aplicacao import CadastrarItem


def cadastrar_valores(cadastro: CadastrarItem, codigo: str, titulo: str) -> str:
    item = cadastro.executar(codigo, titulo)
    return f"Item cadastrado: {item.codigo} — {item.titulo}"


# catalogo/composicao.py
from pathlib import Path

from catalogo.adaptadores import RepositorioEmMemoria, RepositorioJson
from catalogo.aplicacao import CadastrarItem


def montar_com_memoria() -> CadastrarItem:
    return CadastrarItem(RepositorioEmMemoria())


def montar_com_json(caminho: Path) -> CadastrarItem:
    return CadastrarItem(RepositorioJson(caminho))

import pytest

from catalogo.adaptadores import RepositorioEmMemoria, RepositorioJson
from catalogo.aplicacao import CadastrarItem, CodigoDuplicado
from catalogo.dominio import ItemInvalido


@pytest.fixture(params=["memoria", "json"])
def repositorio(request, tmp_path):
    if request.param == "memoria":
        return RepositorioEmMemoria()
    return RepositorioJson(tmp_path / "catalogo.json")


def test_cadastra_item_em_qualquer_adaptador(repositorio):
    cadastro = CadastrarItem(repositorio)

    resultado = cadastro.executar("A1", "Python avançado")

    assert resultado.codigo == "A1"
    assert repositorio.buscar_por_codigo("A1") == resultado


def test_titulo_vazio_e_rejeitado_em_qualquer_adaptador(repositorio):
    cadastro = CadastrarItem(repositorio)

    with pytest.raises(ItemInvalido):
        cadastro.executar("A1", "   ")

    assert repositorio.buscar_por_codigo("A1") is None


def test_codigo_duplicado_e_rejeitado_em_qualquer_adaptador(repositorio):
    cadastro = CadastrarItem(repositorio)
    cadastro.executar("A1", "Python avançado")

    with pytest.raises(CodigoDuplicado):
        cadastro.executar("A1", "Outro título")

    assert repositorio.buscar_por_codigo("A1").titulo == "Python avançado"


def test_rejeicoes_de_negocio_nao_gravam_na_memoria():
    repositorio = RepositorioEmMemoria()
    cadastro = CadastrarItem(repositorio)

    with pytest.raises(ItemInvalido):
        cadastro.executar("A1", "")
    assert repositorio.gravacoes == 0

    cadastro.executar("A1", "Python avançado")
    with pytest.raises(CodigoDuplicado):
        cadastro.executar("A1", "Outro título")
    assert repositorio.gravacoes == 1


def test_json_persiste_apos_recriar_o_adaptador(tmp_path):
    caminho = tmp_path / "catalogo.json"
    CadastrarItem(RepositorioJson(caminho)).executar("A1", "Python avançado")

    repositorio_recriado = RepositorioJson(caminho)

    assert repositorio_recriado.buscar_por_codigo("A1") == ItemInesperadoNaoUsar


# Substitua apenas a última asserção acima por esta versão correta:
# assert repositorio_recriado.buscar_por_codigo("A1").titulo == "Python avançado"