Nossa Stack Tecnológica & Processo de Testes

1

devbox global run -- uv run --with playwright python3 scripts/test_site_playwright_unittest.py

1
2
3
4
5
6
7
8
9

                  │ PT - BR 
──────────────────┼─────────
 Pages            │     231 
 Paginator pages  │       0 
 Non-page files   │       0 
 Static files     │       2 
 Processed images │       0 
 Aliases          │     209 
 Cleaned          │       0 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import unittest
import subprocess
import time
import urllib.request
import re

PORT = 13134
BASE_URL = f"http://localhost:{PORT}"
PROJECT_DIR = "/home/wc/test-with-spring"

class TestHugoSiteE2E(unittest.TestCase):
    hugo_proc = None
    hugo_metrics = {}

    @classmethod
    def parse_hugo_metrics(cls, output: str) -> dict:
        """Extrai as métricas tabulares geradas no console pelo Hugo."""
        metrics = {}
        for line in output.splitlines():
            match = re.search(r'^\s*([A-Za-z\s]+?)\s*│\s*(\d+)', line)
            if match:
                key = match.group(1).strip()
                metrics[key] = int(match.group(2))
        return metrics

    @classmethod
    def setUpClass(cls):
        """Passo 1: Captura métricas do build e sobe o Hugo Server em porta dedicada."""
        print(f"\n[setUpClass] Compilando Hugo para capturar métricas de build...")
        cmd_build = ["devbox", "run", "--", "hugo", "-s", PROJECT_DIR]
        res = subprocess.run(cmd_build, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        cls.hugo_metrics = cls.parse_hugo_metrics(res.stdout + "\n" + res.stderr)
        print(f"[setUpClass] Métricas capturadas: {cls.hugo_metrics}")

        print(f"[setUpClass] Subindo Hugo Server na porta {PORT}...")
        cmd_server = [
            "devbox", "run", "--", "hugo", "server",
            "-s", PROJECT_DIR,
            "-p", str(PORT),
            "--bind", "127.0.0.1",
            "--baseURL", BASE_URL,
            "-D"
        ]
        cls.hugo_proc = subprocess.Popen(
            cmd_server, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True
        )

        # Polling com timeout para garantir que o servidor está pronto
        ready = False
        for _ in range(40):
            time.sleep(0.5)
            try:
                with urllib.request.urlopen(f"{BASE_URL}/", timeout=1) as resp:
                    if resp.status == 200:
                        ready = True
                        break
            except Exception:
                pass

        if not ready:
            raise RuntimeError(f"O servidor Hugo não respondeu a tempo na porta {PORT}")
        print("[setUpClass] Servidor Hugo online e respondendo 200 OK!")

    @classmethod
    def tearDownClass(cls):
        """Passo Final: Garante que o processo seja finalizado sem deixar portas presas."""
        if cls.hugo_proc:
            cls.hugo_proc.terminate()
            try:
                cls.hugo_proc.wait(timeout=3)
            except subprocess.TimeoutExpired:
                cls.hugo_proc.kill()
            print("[tearDownClass] Servidor Hugo finalizado com sucesso.")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    def test_01_hugo_build_metrics(self):
        """Valida que o Hugo gerou todo o volume de páginas e aliases esperado."""
        print(f"\n[Test 1] Validando métricas do Hugo: {self.hugo_metrics}")
        
        # Garante que as 159 aulas + tópicos + pacotes estão presentes
        self.assertIn("Pages", self.hugo_metrics)
        self.assertGreaterEqual(self.hugo_metrics["Pages"], 230)
        
        # Garante que os aliases para compatibilidade com URLs legadas foram compilados
        self.assertIn("Aliases", self.hugo_metrics)
        self.assertGreaterEqual(self.hugo_metrics["Aliases"], 200)

    def test_02_hugo_server_is_up(self):
        """Valida se a home do site está acessível."""
        req = urllib.request.Request(f"{BASE_URL}/")
        with urllib.request.urlopen(req, timeout=5) as resp:
            self.assertEqual(resp.status, 200)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

    def test_site_crawler_playwright(self):
        # Mapa de links: URL -> booleano de visitação
        links_map = {
            f"{BASE_URL}/": False,
            f"{BASE_URL}/packages/": False,
            f"{BASE_URL}/support/": False,
            f"{BASE_URL}/cookie-policy/": False,
            f"{BASE_URL}/no-bullshit-privacy-policy/": False,
        }
        errors = []
        iteration = 0

        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            context = browser.new_context()
            page = context.new_page()

            while True:
                # Localiza a próxima URL não visitada
                pending_urls = [u for u, visited in links_map.items() if not visited]
                if not pending_urls:
                    break

                target_url = pending_urls[0]
                iteration += 1

                try:
                    response = page.goto(target_url, wait_until="load", timeout=12000)
                    time.sleep(0.04) # Estabilização de redirects (<meta http-equiv="refresh">)
                    
                    status = response.status if response else 200
                    if status >= 400:
                        errors.append((target_url, f"HTTP {status}"))
                    
                    # Marca como visitado no mapa
                    links_map[target_url] = True
                    
                    # Trata redirecionamentos canônicos de aliases
                    current_url = self.normalize_url(page.url)
                    if current_url:
                        links_map[current_url] = True

                    # Extrai links internos dinamicamente do DOM
                    hrefs = page.evaluate("""() => {
                        const anchors = Array.from(document.querySelectorAll('a[href]'));
                        return anchors.map(a => a.getAttribute('href'));
                    }""")

                    for href in hrefs:
                        if not href or href.startswith(("mailto:", "javascript:")):
                            continue
                        absolute = urljoin(page.url, href)
                        normalized = self.normalize_url(absolute)
                        if normalized and normalized not in links_map:
                            # Novo link descoberto! Adiciona como pendente
                            links_map[normalized] = False

                except Exception as e:
                    errors.append((target_url, str(e)))
                    links_map[target_url] = True

            context.close()
            browser.close()

        total_discovered = len(links_map)
        total_visited = sum(1 for visited in links_map.values() if visited)

        # Asserções rigorosas da biblioteca unittest:
        self.assertEqual(len(errors), 0, f"Erros encontrados: {errors}")
        self.assertEqual(total_visited, total_discovered, "Inconsistência no mapa de links!")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Info: Running script "uv" on /home/wc/.local/share/devbox/global/default

[setUpClass] Iniciando servidor Hugo na porta 13134...
[setUpClass] Servidor Hugo ativo e pronto para requisições!
.
[Playwright Crawler] Iniciando descoberta e navegação exaustiva de links...
  ✓ [1] [OK] http://localhost:13134/ (Total no mapa: 5)
  ✓ [2] [OK] http://localhost:13134/packages/ (Total no mapa: 9)
  ...
  ✓ [234] [OK] http://localhost:13134/lesson/using-the-same-dbunit-data-sets-from-multiple-maven-modules/

==================================================
RESUMO DA SUÍTE DE TESTES E2E:
Total de links descobertos: 234
Total de links navegados:   234
Erros encontrados:         0
==================================================
.
[tearDownClass] Encerrando processo do Hugo Server na porta 13134...
[tearDownClass] Processo finalizado com sucesso.

----------------------------------------------------------------------
Ran 2 tests in 29.974s

OK