Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 34 de 36 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 4: los casos de uso

8 min de lectura 3 retos

Un caso de uso es una cosa que la app sabe hacer: crear una tarea, completarla, listarlas. En esta fase escribes el paquete internal/casosdeuso, que junta el dominio y el repositorio sin saber nada de la web ni de SQL.

En 4 ideas
1/4

Cada caso de uso es un struct con el repositorio dentro y un método Ejecutar. En PHP es tu final readonly class CrearTareaHandler con el repositorio en el constructor y un __invoke().

1 · Qué es un caso de uso

Piensa en un restaurante. El dominio son las recetas: qué lleva cada plato. El repositorio es la despensa. Un caso de uso es el pedido de un cliente: «una tortilla» hace que alguien mire la receta, coja los huevos de la despensa y sirva el plato. El pedido no sabe si la despensa es una nevera o un almacén, y tampoco sabe si el cliente llamó por teléfono o vino en persona.

Así queda «crear una tarea»: validar con el dominio y guardar con el repositorio.

PHP 8.5crear-tarea-handler.php
<?php
declare(strict_types=1);

namespace App\Application;

use App\Domain\{Prioridad, Tarea, TareaRepository};

final readonly class CrearTareaHandler
{
    public function __construct(private TareaRepository $repo) {}

    /** @param list<string> $etiquetas */
    public function __invoke(string $titulo, Prioridad $prioridad, array $etiquetas = []): Tarea
    {
        // Lanza TituloVacio, TituloLargo...
        $tarea = Tarea::nueva($titulo, $prioridad);
        foreach ($etiquetas as $etiqueta) {
            $tarea->etiquetar($etiqueta);
        }
        return $this->repo->guardar($tarea);
    }
}

// $crear = new CrearTareaHandler($repo);
// $tarea = $crear("Comprar pan", Prioridad::Alta, ["casa"]);
Gocrear_tarea.go
package casosdeuso

// CrearTarea: valida con el dominio y guarda.
type CrearTarea struct {
    repo dominio.RepositorioTareas
}

func NuevoCrearTarea(repo dominio.RepositorioTareas) *CrearTarea {
    return &CrearTarea{repo: repo}
}

func (c *CrearTarea) Ejecutar(titulo string, p dominio.Prioridad, etiquetas ...string) (dominio.Tarea, error) {
    t, err := dominio.NuevaTarea(titulo, p)
    if err != nil {
        return dominio.Tarea{}, err
    }
    for _, e := range etiquetas {
        if err := t.Etiquetar(e); err != nil {
            return dominio.Tarea{}, err
        }
    }
    return c.repo.Guardar(t)
}

// crear := casosdeuso.NuevoCrearTarea(repo)
// t, err := crear.Ejecutar("Comprar pan", dominio.Alta, "casa")

etiquetas ...string es una función variádica (módulo 01): acepta cero, una o muchas etiquetas sueltas, como el string ...$etiquetas de PHP.

Equivalencia POO · PHP → Go

El «servicio de aplicación» de PHP, traducido:

PHPGoQuién lo ve
final readonly class CrearTareaHandlertype CrearTarea structQuien importe casosdeuso
private TareaRepository $repo (promoción en el constructor)repo dominio.RepositorioTareas (minúscula)Solo el paquete casosdeuso
public function __construct(TareaRepository $repo)func NuevoCrearTarea(repo dominio.RepositorioTareas) *CrearTareaCualquiera (normalmente, solo main)
public function __invoke(...)func (c *CrearTarea) Ejecutar(...)Cualquiera; Go no tiene objetos invocables
readonly (nadie cambia el repo después)Campo privado y sin método que lo cambieLo garantiza el paquete, no el compilador

Los otros casos son igual de cortos. ListarTareas llama a repo.Listar(), VerTarea a repo.BuscarPorID(id) y BorrarTarea a repo.Borrar(id). Parecen poca cosa, pero son el sitio donde crecerán las reglas (permisos, avisos, registros) sin tocar ni la web ni el SQL.

2 · Completar: buscar, cambiar y guardar

Completar una tarea tiene tres pasos: buscarla, pedirle al dominio que se complete (con su regla de «no dos veces») y guardarla.

Gomain.go
func (c *CompletarTarea) Ejecutar(id int) (dominio.Tarea, error) {
    t, err := c.repo.BuscarPorID(id)
    if err != nil {
        // Se añade contexto y se conserva el error original con %w.
        return dominio.Tarea{}, fmt.Errorf("completar: %w", err)
    }
    if err := t.Completar(); err != nil {
        return dominio.Tarea{}, fmt.Errorf("completar tarea %d: %w", id, err)
    }
    // Sin esto, el cambio se pierde.
    return c.repo.Guardar(t)
}

¿Por qué? · En PHP no existe

¿Por qué hay que volver a llamar a Guardar? Con Doctrine o Eloquent no hace falta

En PHP los objetos viajan como un mando a distancia (un handle, módulo 03): el repositorio de Doctrine te da el mismo objeto que tiene vigilado, cambias $tarea->hecha y flush() se entera solo.

En Go, BuscarPorID devuelve una Tarea por valor: una fotocopia. Cambiarla no toca lo que hay en el map ni en SQLite. Puede parecer más trabajo, pero es más claro: los cambios solo llegan al almacén cuando llamas a Guardar, en un único sitio y a la vista. Sin cambios «mágicos» que se guardan sin que nadie lo pida.

Míralo pasar con el repositorio en memoria:

Gomain.go
t, _ := repo.BuscarPorID(1)
t.Completar()
// Olvido: falta repo.Guardar(t)
otra, _ := repo.BuscarPorID(1)
// Imprime false: el almacén tiene la tarea sin cambiar.
fmt.Println(otra.Hecha)

Aquí lo tienes completo. Pulsa Ejecutar y mira cómo la segunda vez sale el error del dominio, envuelto pero reconocible:

Gomain.go
package main

import (
    "errors"
    "fmt"
)

var (
    ErrTareaNoEncontrada = errors.New("tarea no encontrada")
    ErrYaCompletada      = errors.New("la tarea ya estaba completada")
)

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

func (t *Tarea) Completar() error {
    if t.Hecha {
        return ErrYaCompletada
    }
    t.Hecha = true
    return nil
}

type RepositorioTareas interface {
    Guardar(t Tarea) (Tarea, error)
    BuscarPorID(id int) (Tarea, error)
}

// Repositorio en memoria, versión corta (sin Mutex ni Listar).
type Memoria struct {
    tareas map[int]Tarea
}

func (m *Memoria) Guardar(t Tarea) (Tarea, error) {
    m.tareas[t.ID] = t
    return t, nil
}

func (m *Memoria) BuscarPorID(id int) (Tarea, error) {
    t, ok := m.tareas[id]
    if !ok {
        return Tarea{}, fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada)
    }
    return t, nil
}

type CompletarTarea struct {
    repo RepositorioTareas
}

func (c *CompletarTarea) Ejecutar(id int) (Tarea, error) {
    t, err := c.repo.BuscarPorID(id)
    if err != nil {
        return Tarea{}, fmt.Errorf("completar: %w", err)
    }
    if err := t.Completar(); err != nil {
        return Tarea{}, fmt.Errorf("completar tarea %d: %w", id, err)
    }
    return c.repo.Guardar(t)
}

func main() {
    repo := &Memoria{tareas: map[int]Tarea{1: {ID: 1, Titulo: "Comprar pan"}}}
    completar := &CompletarTarea{repo: repo}

    t, err := completar.Ejecutar(1)
    fmt.Println("1ª:", t.Hecha, err)

    _, err = completar.Ejecutar(1)
    fmt.Println("2ª:", err)
    fmt.Println("   ¿ya completada?", errors.Is(err, ErrYaCompletada))

    _, err = completar.Ejecutar(9)
    fmt.Println("9:", err)
    fmt.Println("   ¿no encontrada?", errors.Is(err, ErrTareaNoEncontrada))
}

3 · Probar con un repositorio falso

¿Cómo pruebas que tu caso de uso se porta bien cuando el disco se llena? No vas a llenar el disco. Te fabricas un repositorio falso que falla a propósito, como un simulacro de incendio.

No hace falta ninguna librería de mocks: basta un tipo con los métodos de la interfaz. Y con embedding (módulo 05) solo reescribes el método que quieres que falle; los demás los hereda del repositorio en memoria:

Gomain.go
package main

import (
    "errors"
    "fmt"
)

type Tarea struct {
    ID    int
    Hecha bool
}

type RepositorioTareas interface {
    Guardar(t Tarea) (Tarea, error)
    Listar() ([]Tarea, error)
}

type Memoria struct {
    tareas []Tarea
}

func (m *Memoria) Guardar(t Tarea) (Tarea, error) {
    t.ID = len(m.tareas) + 1
    m.tareas = append(m.tareas, t)
    return t, nil
}

func (m *Memoria) Listar() ([]Tarea, error) {
    return m.tareas, nil
}

var errDisco = errors.New("disco lleno")

// repoRoto se comporta como Memoria salvo en Listar, que siempre falla.
// En PHP: $repo = $this->createMock(TareaRepository::class);
type repoRoto struct {
    *Memoria
}

func (r repoRoto) Listar() ([]Tarea, error) {
    return nil, errDisco
}

type ContarPendientes struct {
    repo RepositorioTareas
}

func (c *ContarPendientes) Ejecutar() (int, error) {
    tareas, err := c.repo.Listar()
    if err != nil {
        return 0, fmt.Errorf("contar pendientes: %w", err)
    }
    n := 0
    for _, t := range tareas {
        if !t.Hecha {
            n++
        }
    }
    return n, nil
}

func main() {
    bueno := &Memoria{}
    bueno.Guardar(Tarea{})
    bueno.Guardar(Tarea{Hecha: true})
    fmt.Println((&ContarPendientes{repo: bueno}).Ejecutar())

    roto := repoRoto{Memoria: &Memoria{}}
    n, err := (&ContarPendientes{repo: roto}).Ejecutar()
    fmt.Println(n, err, "→", errors.Is(err, errDisco))
}
Para probar…UsaEn PHPUnit
El camino felizrepositorio.NuevoMemoria() de verdadUn repositorio en memoria o SQLite :memory:
Que un error se propagaUn struct falso que devuelve un errorcreateMock() + willThrowException()
Que se llamó a GuardarUn falso que cuenta las llamadas en un campoexpects($this->once())->method('guardar')

4 · Cablear las piezas a mano

Para no pasar cinco casos de uso sueltos a la web, se agrupan en un struct y se construyen todos de golpe con el mismo repositorio:

Gomain.go
// Tareas agrupa los casos de uso para pasárselos al controlador.
type Tareas struct {
    Crear     *CrearTarea
    Listar    *ListarTareas
    Ver       *VerTarea
    Completar *CompletarTarea
    Borrar    *BorrarTarea
}

func Nuevos(repo dominio.RepositorioTareas) Tareas {
    return Tareas{
        Crear:     NuevoCrearTarea(repo),
        Listar:    NuevoListarTareas(repo),
        Ver:       NuevoVerTarea(repo),
        Completar: NuevoCompletarTarea(repo),
        Borrar:    NuevoBorrarTarea(repo),
    }
}

// En cmd/tareas/main.go:
// repo := repositorio.NuevoSQLite(db)
// cu := casosdeuso.Nuevos(repo)

Cambiar SQLite por la memoria (o, mañana, por MySQL) es cambiar una línea en main.go. Ningún caso de uso se entera.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Crear de verdad

Completa Ejecutar(titulo string) (Tarea, error) de CrearTarea: crea la tarea con NuevaTarea (si da error, devuélvelo sin guardar nada) y guárdala con el repositorio, devolviendo la tarea ya con su ID. Es el __invoke() de tu CrearTareaHandler en PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.

Gomain.go · editable

Resumen

Lo que te llevas de esta lección

  1. Un caso de uso = un struct con el repositorio + Ejecutar (en PHP, una clase …Handler con __invoke()).
  2. El repositorio entra como interfaz por NuevoX(repo) (en PHP, el constructor que recibe TareaRepository).
  3. Buscar, cambiar y volver a guardar: la Tarea es una copia (en PHP, Doctrine y flush() lo hacen solos).
  4. Los errores suben envueltos con %w; el caso de uso no decide el código HTTP (en PHP, la excepción sube hasta el controlador).
  5. Repositorios falsos con un struct y embedding, sin librería de mocks (en PHP, createMock()).

Para recordarlo: «Busca, Cambia, Guarda»

BBusca
t, err := repo.BuscarPorID(id)
CCambia
t.Completar()
GGuarda
repo.Guardar(t)

Todo caso de uso que modifica algo sigue estos tres pasos. Si te saltas la G, el cambio se queda en una fotocopia que nadie guarda.