Proyecto, testing y calidad

module github.com/daniel/mi-servicio

go 1.24

require (
	github.com/go-chi/chi/v5 v5.1.0
	github.com/jackc/pgx/v5 v5.7.1
)

package precios

import "testing"

func TestAplicarDescuento(t *testing.T) {
	casos := []struct {
		nombre   string
		precio   float64
		cupon    string
		esperado float64
	}{
		{"sin cupón", 100, "", 100},
		{"cupón 10%", 100, "DIEZ", 90},
		{"cupón inválido no descuenta", 100, "FALSO", 100},
		{"precio cero", 0, "DIEZ", 0},
	}

	for _, c := range casos {
		t.Run(c.nombre, func(t *testing.T) { // subtests con nombre, como @Nested
			got := AplicarDescuento(c.precio, c.cupon)
			if got != c.esperado {
				t.Errorf("AplicarDescuento(%v, %q) = %v; quería %v",
					c.precio, c.cupon, got, c.esperado)
			}
		})
	}
}

// La interfaz que usa el handler (definida por el consumidor):
type BuscadorTareas interface {
	PorID(id int) (Tarea, error)
}

// El "mock": un struct que la cumple. Eso es todo.
type buscadorFalso struct {
	tarea Tarea
	err   error
}

func (b buscadorFalso) PorID(int) (Tarea, error) { return b.tarea, b.err }

func TestGetTarea(t *testing.T) {
	h := NuevoHandler(buscadorFalso{tarea: Tarea{ID: 1, Titulo: "estudiar Go"}})

	// httptest: servidor y request falsos de la stdlib (tu MockMvc)
	req := httptest.NewRequest("GET", "/tareas/1", nil)
	rec := httptest.NewRecorder()

	h.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d; quería 200", rec.Code)
	}
}

// Benchmark: mide ns/op y allocs/op. Go 1.24 introdujo b.Loop().
func BenchmarkParsear(b *testing.B) {
	for b.Loop() {
		Parsear(entradaEjemplo)
	}
}
// $ go test -bench=. -benchmem
// BenchmarkParsear-8   1204818   983 ns/op   256 B/op   3 allocs/op

// Fuzzing: el motor genera entradas mutadas buscando panics y fallos.
// Así se encuentran los bugs de parseo que ningún humano imagina.
func FuzzParsear(f *testing.F) {
	f.Add("entrada semilla")            // corpus inicial
	f.Fuzz(func(t *testing.T, s string) {
		_, err := Parsear(s)
		if err == nil {
			return // entrada válida: ok
		}
		// si err != nil está bien; lo que NUNCA debe pasar es un panic
	})
}
// $ go test -fuzz=FuzzParsear -fuzztime=30s

# golangci-lint run  ← corre esto en local y en CI
linters:
  enable:
    - govet          # el go vet de siempre
    - staticcheck    # el linter más querido: cientos de chequeos serios
    - errcheck       # ¿ignoraste un error sin querer? te delata
    - unused         # código muerto
    - ineffassign    # asignaciones que nadie lee
    - gocritic       # estilo y rendimiento
    - misspell       # typos en comentarios y strings

linters-settings:
  errcheck:
    check-type-assertions: true   # v, ok := x.(T) — exige el ok

name: ci
on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-go@v5
        with:
          go-version: "1.24"
          cache: true            # cachea módulos y build: corre aún más rápido

      - name: Vet
        run: go vet ./...

      - name: Tests con detector de races
        run: go test -race -coverprofile=cover.out ./...

      - name: Build
        run: go build ./...

      - name: Lint
        uses: golangci/golangci-lint-action@v6

type Servidor struct {
	puerto  int
	timeout time.Duration
	log     *slog.Logger
}

// Una Opción es una función que modifica el servidor:
type Opcion func(*Servidor)

func ConPuerto(p int) Opcion {
	return func(s *Servidor) { s.puerto = p }
}

func ConTimeout(d time.Duration) Opcion {
	return func(s *Servidor) { s.timeout = d }
}

// El constructor pone defaults sensatos y aplica las opciones recibidas:
func NewServidor(opts ...Opcion) *Servidor {
	s := &Servidor{
		puerto:  8080,
		timeout: 5 * time.Second,
		log:     slog.Default(),
	}
	for _, aplicar := range opts {
		aplicar(s)
	}
	return s
}

// Uso: legible, extensible sin romper llamadas existentes, sin builder classes
srv := NewServidor(ConPuerto(9090), ConTimeout(10*time.Second))

// Cada capa declara sus dependencias como interfaces en el constructor.
// main() las construye en orden y las conecta. Eso es TODO el DI de Go:
func main() {
	db := store.Abrir(os.Getenv("DATABASE_URL"))
	repo := store.NewUsuarioRepo(db)          // capa datos
	svc := service.NewUsuarios(repo)          // capa negocio (recibe interfaz)
	api := handler.New(svc)                   // capa HTTP (recibe interfaz)

	http.ListenAndServe(":8080", api.Router())
}
// Ventaja sobre Spring: el grafo de dependencias es código que se lee
// de arriba a abajo. Ctrl+click responde "¿de dónde sale esto?" siempre.
// ¿Proyecto enorme? Existe google/wire (genera este cableado), pero
// la mayoría de equipos simplemente escriben main() a mano.