Git y GitHub: convierte cambios en una historia verificable

# Terminal: PowerShell. Punto de partida: carpeta padre del laboratorio.
& {
    Get-Command -Name git, python -ErrorAction Stop | Out-Null

    git --version
    if ($LASTEXITCODE -ne 0) { throw "Git no esta disponible." }

    python --version
    if ($LASTEXITCODE -ne 0) { throw "Python no esta disponible." }

    $rutaLaboratorio = Join-Path (Get-Location).Path "bitacora-git"
    if (Test-Path -LiteralPath $rutaLaboratorio) {
        throw "La carpeta bitacora-git ya existe. Elige otra carpeta padre."
    }

    $nombreAutor = (Read-Host "Nombre para tus commits").Trim()
    $correoAutor = (Read-Host "Correo verificado de GitHub o correo de privacidad").Trim()

    if ([string]::IsNullOrWhiteSpace($nombreAutor) -or
        [string]::IsNullOrWhiteSpace($correoAutor)) {
        throw "El nombre y el correo deben tener contenido."
    }

    New-Item -ItemType Directory -Path $rutaLaboratorio -ErrorAction Stop | Out-Null
    Set-Location -LiteralPath $rutaLaboratorio -ErrorAction Stop

    git init -b main
    if ($LASTEXITCODE -ne 0) { throw "No se pudo iniciar el repositorio." }

    git config --local user.name $nombreAutor
    if ($LASTEXITCODE -ne 0) { throw "No se pudo guardar el nombre." }

    git config --local user.email $correoAutor
    if ($LASTEXITCODE -ne 0) { throw "No se pudo guardar el correo." }

    New-Item -ItemType Directory -Path "tests" -ErrorAction Stop | Out-Null

    git config --local --get user.name
    git config --local --get user.email
    git status --short --branch
}

# Archivo: bitacora.py

def normalizar_titulo(titulo: str) -> str:
    """Quita espacios en blanco de los extremos."""
    return titulo.strip()

# Archivo: tests/test_bitacora.py

import unittest

from bitacora import normalizar_titulo


class NormalizarTituloTests(unittest.TestCase):
    def test_titulo_sin_espacios(self):
        self.assertEqual(normalizar_titulo("Hola"), "Hola")

    def test_recorta_espacios_laterales(self):
        self.assertEqual(normalizar_titulo("  Hola  "), "Hola")

    def test_conserva_espacios_interiores(self):
        self.assertEqual(normalizar_titulo("  Hola mundo  "), "Hola mundo")

    def test_conserva_unicode(self):
        self.assertEqual(normalizar_titulo("  Café  "), "Café")


if __name__ == "__main__":
    unittest.main()

# Archivo de destino: .gitignore

# Caches y archivos compilados de Python
__pycache__/
*.py[cod]

# Entornos virtuales locales
.venv/
venv/

# Configuracion local y posibles secretos
.env
.env.*
!.env.example

# Terminal: PowerShell. Repositorio A, dentro de bitacora-git.
& {
    git status --short --branch
    git --no-pager diff

    python -m unittest discover -s tests -v
    if ($LASTEXITCODE -ne 0) {
        throw "Corrige las pruebas antes de continuar."
    }

    git add -- bitacora.py tests/test_bitacora.py .gitignore
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudieron preparar los archivos."
    }

    git diff --cached --check
    if ($LASTEXITCODE -ne 0) {
        throw "Revisa los espacios y conflictos indicados."
    }

    git --no-pager diff --cached
    [void](Read-Host "Revisa el contenido preparado. Pulsa Enter para crear el commit")

    git commit -m "Crea el normalizador de titulos y sus pruebas"
    if ($LASTEXITCODE -ne 0) {
        throw "El commit no se completo."
    }

    git --no-pager show --stat --oneline HEAD
    git status --short --branch
}

# Terminal: PowerShell. Repositorio A, rama main.
# Antes de ejecutar: guarda las dos ediciones indicadas en el texto anterior.
& {
    python -m unittest discover -s tests -v
    if ($LASTEXITCODE -ne 0) {
        throw "Corrige las pruebas antes de continuar."
    }

    git --no-pager diff -- bitacora.py tests/test_bitacora.py

    # Primera seleccion: y para bitacora.py; n para tests/test_bitacora.py.
    git add -p -- bitacora.py tests/test_bitacora.py
    if ($LASTEXITCODE -ne 0) {
        throw "La seleccion no se completo."
    }

    $archivosPreparados = @(git diff --cached --name-only)
    if ($archivosPreparados.Count -ne 1 -or
        $archivosPreparados[0] -ne "bitacora.py") {
        throw "El primer commit debe preparar solo bitacora.py. Revisa el staging."
    }

    git status --short
    git --no-pager diff --cached
    [void](Read-Host "Revisa la docstring preparada. Pulsa Enter para registrarla")

    git commit -m "Aclara el alcance del recorte de titulos"
    if ($LASTEXITCODE -ne 0) {
        throw "El commit de documentacion no se completo."
    }

    # Segunda seleccion: y para la asercion de Unicode pendiente.
    git add -p -- tests/test_bitacora.py
    if ($LASTEXITCODE -ne 0) {
        throw "La segunda seleccion no se completo."
    }

    $archivosPreparados = @(git diff --cached --name-only)
    if ($archivosPreparados.Count -ne 1 -or
        $archivosPreparados[0] -ne "tests/test_bitacora.py") {
        throw "El segundo commit debe preparar solo el archivo de pruebas."
    }

    git --no-pager diff --cached
    [void](Read-Host "Revisa la nueva asercion. Pulsa Enter para registrarla")

    git commit -m "Comprueba otro titulo con caracteres Unicode"
    if ($LASTEXITCODE -ne 0) {
        throw "El commit de pruebas no se completo."
    }

    git --no-pager log -3 --oneline
    git status --short --branch
}

# Terminal: PowerShell. Repositorio A, dentro de bitacora-git.
# Estas ordenes inspeccionan el historial sin modificarlo.

git --no-pager log --oneline --graph --decorate --all

# Identificador completo de la revision actual.
git rev-parse HEAD

# Datos del commit actual.
git --no-pager show --format=fuller --no-patch HEAD
git cat-file -p HEAD

# El commit anterior debe mostrar la aclaracion de la docstring.
git --no-pager show "HEAD~1" -- bitacora.py

# Diferencias acumuladas desde el primer commit hasta el actual.
git --no-pager diff "HEAD~2" HEAD -- bitacora.py tests/test_bitacora.py

git status --short --branch

# Repositorio A, dentro de bitacora-git.
# Punto de partida: main limpio.
# Despues, guarda los dos bloques Python siguientes
# en bitacora.py y tests/test_bitacora.py.

& {
    if (@(git status --porcelain).Count -ne 0) {
        throw "Conserva o registra los cambios pendientes antes de crear la rama."
    }

    git switch main
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo activar main."
    }

    git switch -c mejora/validar-titulos
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo crear la rama de mejora."
    }

    git branch --show-current
    git status --short --branch
}

# Archivo: bitacora.py

def normalizar_titulo(titulo: str) -> str:
    """Recorta los extremos y rechaza titulos vacios."""
    normalizado = titulo.strip()
    if not normalizado:
        raise ValueError("El titulo no puede estar vacio.")
    return normalizado

# Archivo: tests/test_bitacora.py
# Los dos casos nuevos expresan el requisito incorporado.

import unittest

from bitacora import normalizar_titulo


class NormalizarTituloTests(unittest.TestCase):
    def test_titulo_sin_espacios(self):
        self.assertEqual(normalizar_titulo("Hola"), "Hola")

    def test_recorta_espacios_laterales(self):
        self.assertEqual(normalizar_titulo("  Hola  "), "Hola")

    def test_conserva_espacios_interiores(self):
        self.assertEqual(
            normalizar_titulo("  Hola mundo  "),
            "Hola mundo",
        )

    def test_conserva_unicode(self):
        self.assertEqual(normalizar_titulo("  Café  "), "Café")
        self.assertEqual(normalizar_titulo("  Acción  "), "Acción")

    def test_rechaza_cadena_vacia(self):
        with self.assertRaises(ValueError):
            normalizar_titulo("")

    def test_rechaza_solo_espacios(self):
        with self.assertRaises(ValueError):
            normalizar_titulo("   ")


if __name__ == "__main__":
    unittest.main()

# Repositorio A.
# Guarda primero los archivos Python de los dos bloques anteriores.
# Se esperan seis pruebas.

& {
    if ((git branch --show-current).Trim() -ne "mejora/validar-titulos") {
        throw "Activa la rama mejora/validar-titulos antes de registrar la mejora."
    }

    python -m unittest discover -s tests -v
    if ($LASTEXITCODE -ne 0) {
        throw "Corrige las pruebas antes de registrar el cambio."
    }

    git --no-pager diff -- bitacora.py tests/test_bitacora.py

    git add -- bitacora.py tests/test_bitacora.py
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudieron preparar los dos archivos."
    }

    git --no-pager diff --cached
    [void](Read-Host "Revisa implementacion y pruebas. Pulsa Enter para registrar la mejora")

    git commit -m "Rechaza titulos vacios tras normalizarlos"
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo crear el commit de mejora."
    }

    git --no-pager diff main...HEAD -- bitacora.py tests/test_bitacora.py
    git status --short --branch
}

# Repositorio A.
# Utiliza la URL HTTPS de TU repositorio vacio.

& {
    if (@(git remote) -contains "origin") {
        throw "origin ya existe. Comprueba su URL antes de continuar."
    }

    $urlRepositorio = (Read-Host "URL HTTPS de tu repositorio de GitHub").Trim()
    $uriRepositorio = [uri]$urlRepositorio

    if ($uriRepositorio.Scheme -ne "https" -or
        $uriRepositorio.Host -ne "github.com" -or
        $uriRepositorio.UserInfo -ne "" -or
        $uriRepositorio.AbsolutePath.Trim("/").Split("/").Count -ne 2) {
        throw "Utiliza una URL HTTPS de GitHub sin credenciales dentro de ella."
    }

    git remote add origin $urlRepositorio
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo registrar origin."
    }

    git remote -v
    [void](Read-Host "Confirma que origin es tu repositorio. Pulsa Enter para enviar las ramas")

    git push -u origin main
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo enviar main. Revisa el acceso al remoto."
    }

    git push -u origin mejora/validar-titulos
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo enviar la mejora."
    }

    git branch -vv
}

# Comienza en el repositorio A.
# Al finalizar quedaras dentro del clon B.

& {
    $rutaA = (git rev-parse --show-toplevel).Trim()
    if ($LASTEXITCODE -ne 0) {
        throw "Abre primero el repositorio A."
    }

    $urlOrigen = (git remote get-url origin).Trim()
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo consultar origin."
    }

    $nombreAutor = (git config --local --get user.name).Trim()
    $correoAutor = (git config --local --get user.email).Trim()

    $rutaB = Join-Path (Split-Path -Parent $rutaA) "bitacora-git-colaborador"

    if (Test-Path -LiteralPath $rutaB) {
        throw "La carpeta del segundo clon ya existe. Inspeccionala antes de continuar."
    }

    git clone --branch main $urlOrigen $rutaB
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo crear el segundo clon."
    }

    git -C $rutaB config --local user.name $nombreAutor
    git -C $rutaB config --local user.email $correoAutor

    Set-Location -LiteralPath $rutaB -ErrorAction Stop

    git remote -v
    git branch -vv
    git status --short --branch
}

# Comienza en B: bitacora-git-colaborador.
# Guarda antes la linea .DS_Store al final de su .gitignore.

& {
    $rutaB = (git rev-parse --show-toplevel).Trim()

    if ((Split-Path -Leaf $rutaB) -ne "bitacora-git-colaborador") {
        throw "Este bloque comienza en el clon B."
    }

    $rutaA = Join-Path (Split-Path -Parent $rutaB) "bitacora-git"

    git switch main
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo activar main en B."
    }

    git --no-pager diff -- .gitignore
    git add -- .gitignore

    git commit -m "Excluye metadatos locales de macOS"
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo registrar el cambio independiente."
    }

    git push origin main
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo enviar el avance desde B."
    }

    Set-Location -LiteralPath $rutaA -ErrorAction Stop

    git switch main
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo activar main en A."
    }

    git fetch origin
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo actualizar la informacion del remoto."
    }

    git --no-pager log --oneline main..origin/main
    git --no-pager diff main origin/main -- .gitignore

    git pull --ff-only
    if ($LASTEXITCODE -ne 0) {
        throw "No hubo fast-forward. Inspecciona la divergencia."
    }

    git switch mejora/validar-titulos
    if ($LASTEXITCODE -ne 0) {
        throw "No se pudo volver a la rama de mejora."
    }

    git status --short --branch
}

# Archivo: .github/workflows/ci.yml

name: Pruebas de bitacora

on:
  push:
  pull_request:

permissions:
  contents: read

jobs:
  unittest-python:
    name: unittest-python
    runs-on: ubuntu-24.04
    timeout-minutes: 5

    steps:
      - name: Obtener la revision
        uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6
        with:
          persist-credentials: false

      - name: Preparar Python
        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
        with:
          python-version: "3.12"

      - name: Identificar el entorno probado
        run: |
          git rev-parse HEAD
          python --version

      - name: Ejecutar las pruebas
        run: python -m unittest discover -s tests -v