Pular para o conteúdo
Skillpedia
Testes280 mil · #47

django-verification

Ajuda seu agente a executar uma verificação completa em aplicações Django antes do lançamento. Ele realiza checagens de ambiente, linting, testes e varreduras de segurança, gerando um relatório final.

O que ela faz

Verifica se um projeto Django está pronto para ser lançado, checando a qualidade do código, segurança e configurações.

Quando usar

  • ✓Antes de enviar um código novo para revisão.
  • ✓Após fazer grandes mudanças no projeto.
  • ✓Antes de colocar o projeto no ar (produção).

Exemplo do que pedir para a IA

“Verifique meu projeto Django antes de eu enviar para revisão.”

Quer saber mais? Abra as seções abaixo.

Como usar

O jeito mais fácil: copie a mensagem abaixo e cole no Claude, ChatGPT, Cursor ou outra IA. Ela lê a skill e segue as instruções.

Link da skill

https://github.com/affaan-m/ECC/blob/main/pi/core/skills/django-verification/SKILL.md

Mensagem pronta para colar

Use esta skill para me ajudar: https://github.com/affaan-m/ECC/blob/main/pi/core/skills/django-verification/SKILL.md Leia o arquivo SKILL.md desse link e siga as instruções dele na minha tarefa.
Como funciona

Ele executa várias ferramentas que analisam o código, testam o programa e procuram por problemas de segurança e configuração.

Instalação

Jeito mais fácil: copie o link da skill e cole no Claude, ChatGPT ou Cursor pedindo para seguir as instruções.

No terminal (Claude Code, Codex, Cursor), na pasta do projeto:

npx skills add affaan-m/ECC --skill django-verification

Ou baixe só o arquivo:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/django-verification/SKILL.md -o SKILL.md
Conteúdo técnico (SKILL.md)

Tradução do texto original do autor no GitHub. Os comandos e códigos estão como no original.

Loop de Verificação do Django

Execute antes de Pull Requests, após grandes mudanças e antes do deploy para garantir a qualidade e segurança da aplicação Django.

Quando Ativar

  • Antes de abrir um pull request para um projeto Django
  • Após grandes mudanças em modelos, atualizações de migrações ou upgrades de dependências
  • Verificação pré-deploy para staging ou produção
  • Execução do pipeline completo: ambiente → lint → teste → segurança → prontidão para deploy
  • Validação da segurança das migrações e cobertura de testes

Fase 1: Verificação do Ambiente

# Verify Python version
python --version  # Should match project requirements

# Check virtual environment
which python
pip list --outdated

# Verify environment variables
python -c "import os; import environ; print('DJANGO_SECRET_KEY set' if os.environ.get('DJANGO_SECRET_KEY') else 'MISSING: DJANGO_SECRET_KEY')"

Se o ambiente estiver mal configurado, pare e corrija.

Fase 2: Qualidade e Formatação do Código

# Type checking
mypy . --config-file pyproject.toml

# Linting with ruff
ruff check . --fix

# Formatting with black
black . --check
black .  # Auto-fix

# Import sorting
isort . --check-only
isort .  # Auto-fix

# Django-specific checks
python manage.py check --deploy

Problemas comuns:

  • Falta de type hints em funções públicas
  • Violações de formatação PEP 8
  • Imports não ordenados
  • Configurações de debug deixadas na configuração de produção

Fase 3: Migrações

# Check for unapplied migrations
python manage.py showmigrations

# Create missing migrations
python manage.py makemigrations --check

# Dry-run migration application
python manage.py migrate --plan

# Apply migrations (test environment)
python manage.py migrate

# Check for migration conflicts
python manage.py makemigrations --merge  # Only if conflicts exist

Relatório:

  • Número de migrações pendentes
  • Quaisquer conflitos de migração
  • Mudanças de modelo sem migrações

Fase 4: Testes + Cobertura

# Run all tests with pytest
pytest --cov=apps --cov-report=html --cov-report=term-missing --reuse-db

# Run specific app tests
pytest apps/users/tests/

# Run with markers
pytest -m "not slow"  # Skip slow tests
pytest -m integration  # Only integration tests

# Coverage report
open htmlcov/index.html

Relatório:

  • Total de testes: X passaram, Y falharam, Z foram pulados
  • Cobertura geral: XX%
  • Detalhamento da cobertura por app

Metas de cobertura:

Componente Meta
Modelos 90%+
Serializadores 85%+
Views 80%+
Serviços 90%+
Geral 80%+

Fase 5: Verificação de Segurança

# Dependency vulnerabilities
pip-audit
safety check --full-report

# Django security checks
python manage.py check --deploy

# Bandit security linter
bandit -r . -f json -o bandit-report.json

# Secret scanning (if gitleaks is installed)
gitleaks detect --source . --verbose

# Environment variable check
python -c "from django.core.exceptions import ImproperlyConfigured; from django.conf import settings; settings.DEBUG"

Relatório:

  • Dependências vulneráveis encontradas
  • Problemas de configuração de segurança
  • Segredos hardcoded detectados
  • Status do modo DEBUG (deve ser False em produção)

Fase 6: Comandos de Gerenciamento do Django

# Check for model issues
python manage.py check

# Collect static files
python manage.py collectstatic --noinput --clear

# Create superuser (if needed for tests)
echo "from apps.users.models import User; User.objects.create_superuser('admin@example.com', 'admin')" | python manage.py shell

# Database integrity
python manage.py check --database default

# Cache verification (if using Redis)
python -c "from django.core.cache import cache; cache.set('test', 'value', 10); print(cache.get('test'))"

Fase 7: Verificações de Performance

# Django Debug Toolbar output (check for N+1 queries)
# Run in dev mode with DEBUG=True and access a page
# Look for duplicate queries in SQL panel

# Query count analysis
django-admin debugsqlshell  # If django-debug-sqlshell installed

# Check for missing indexes
python manage.py shell << EOF
from django.db import connection
with connection.cursor() as cursor:
    cursor.execute("SELECT table_name, index_name FROM information_schema.statistics WHERE table_schema = 'public'")
    print(cursor.fetchall())
EOF

Relatório:

  • Número de queries por página (deve ser < 50 para páginas típicas)
  • Índices de banco de dados ausentes
  • Queries duplicadas detectadas

Fase 8: Assets Estáticos

# Verifica dependências npm (se estiver usando npm)
npm audit
npm audit fix

# Constrói arquivos estáticos (se estiver usando webpack/vite)
npm run build


…
Perguntas frequentes

O que são 'migrations'?

São como 'instruções' para o banco de dados, que ajudam a manter a estrutura dele atualizada com as mudanças no código.

O que é 'linting'?

É um processo que verifica se o código está escrito de forma organizada e seguindo as regras de estilo, como um revisor de texto.

Por que verificar a segurança?

Para encontrar e corrigir falhas que poderiam ser usadas por pessoas mal-intencionadas para acessar ou danificar o projeto.

Detalhes

Descrição original do autor

Run the full Django verification loop — environment check, mypy/ruff/black linting, migration safety, pytest with coverage targets, pip-audit and bandit security scans, settings and logging review, and diff review — producing a phased pass/fail report before release or PR. Use when preparing a Django pull request, validating migrations or coverage, or running pre-deploy readiness checks.

repo: affaan-m/ECC

Popularidade

Estrelas no GitHub
280 mil
Posição no ranking
#47
Licença
MIT
Atualizada em
15/10/2026

Essa skill é útil?

0

Entre para votar.

Comentários

  • …

Mais skills deste repositório

Skills parecidas