Os sistemas de registro de cursos universitários usam reCAPTCHA v2 para proteger formulários de inscrição, páginas de pesquisa de turmas e planejadores de horários. As equipes de controle de qualidade que testam esses sistemas precisam lidar com CAPTCHAs em vários cenários de teste - fluxos de trabalho de inscrição, lógica de lista de espera, disponibilidade de vagas e cumprimento de prazos. Veja como integrar a solução de CAPTCHA aos testes de registro.
Onde os CAPTCHAs aparecem nos sistemas de registro
| Etapa de registro | Tipo CAPTCHA | Objetivo |
|---|---|---|
| Página de login do aluno | reCAPTCHA v2 | Evitar o excesso de credenciais |
| Pesquisa de curso/browse | reCAPTCHA v2 | Limitar pesquisas automatizadas |
| Cursos Add/drop | reCAPTCHA v2 | Impedir a inscrição automatizada |
| Cadastro na lista de espera | reCAPTCHA v2 | Bloquear bots de registro automático |
| Planejador de cronograma | Cloudflare Turnstile | Proteja ferramentas interativas |
| Solicitações de transcrição | reCAPTCHA v2 | Verifique o usuário humano |
Teste de registro com solução CAPTCHA
import requests
import time
import re
class RegistrationTester:
def __init__(self, api_key, portal_url):
self.api_key = api_key
self.portal_url = portal_url
self.session = requests.Session()
self.session.headers.update({
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
})
def test_login(self, student_id, password):
"""Test login flow with CAPTCHA handling."""
login_page = self.session.get(f"{self.portal_url}/login")
site_key = self._extract_site_key(login_page.text)
token = self._solve_recaptcha(site_key, f"{self.portal_url}/login")
response = self.session.post(f"{self.portal_url}/login", data={
"studentId": student_id,
"password": password,
"g-recaptcha-response": token
})
return {
"status": response.status_code,
"redirected": response.url != f"{self.portal_url}/login",
"success": "dashboard" in response.url or response.status_code == 200
}
def test_course_search(self, term, department, level=None):
"""Test course search returns correct results."""
params = {"term": term, "dept": department}
if level:
params["level"] = level
response = self.session.get(
f"{self.portal_url}/courses/search", params=params
)
if self._has_captcha(response.text):
site_key = self._extract_site_key(response.text)
token = self._solve_recaptcha(
site_key, f"{self.portal_url}/courses/search"
)
response = self.session.post(
f"{self.portal_url}/courses/search",
data={**params, "g-recaptcha-response": token}
)
courses = self._parse_courses(response.text)
return {
"count": len(courses),
"courses": courses,
"all_match_dept": all(
c["department"] == department for c in courses
)
}
def test_enrollment(self, course_id, section):
"""Test enrolling in a course section."""
enroll_page = self.session.get(
f"{self.portal_url}/enroll/{course_id}/{section}"
)
if self._has_captcha(enroll_page.text):
site_key = self._extract_site_key(enroll_page.text)
token = self._solve_recaptcha(
site_key,
f"{self.portal_url}/enroll/{course_id}/{section}"
)
else:
token = None
form_data = {
"courseId": course_id,
"section": section,
"confirm": "true"
}
if token:
form_data["g-recaptcha-response"] = token
response = self.session.post(
f"{self.portal_url}/enroll/submit",
data=form_data
)
return {
"status": response.status_code,
"enrolled": "success" in response.text.lower(),
"waitlisted": "waitlist" in response.text.lower(),
"error": self._extract_error(response.text)
}
def test_seat_availability(self, course_ids):
"""Test seat availability display for multiple courses."""
results = []
for course_id in course_ids:
response = self.session.get(
f"{self.portal_url}/courses/{course_id}"
)
if self._has_captcha(response.text):
site_key = self._extract_site_key(response.text)
token = self._solve_recaptcha(
site_key, f"{self.portal_url}/courses/{course_id}"
)
response = self.session.post(
f"{self.portal_url}/courses/{course_id}",
data={"g-recaptcha-response": token}
)
availability = self._parse_availability(response.text)
results.append({"course_id": course_id, **availability})
return results
def _has_captcha(self, html):
return "g-recaptcha" in html or "recaptcha" in html.lower()
def _extract_site_key(self, html):
match = re.search(r'data-sitekey="([^"]+)"', html)
if match:
return match.group(1)
raise ValueError("reCAPTCHA site key not found")
def _solve_recaptcha(self, site_key, page_url):
resp = requests.post("https://ocr.captchaai.com/in.php", data={
"key": self.api_key,
"method": "userrecaptcha",
"googlekey": site_key,
"pageurl": page_url,
"json": 1
})
task_id = resp.json()["request"]
for _ in range(60):
time.sleep(3)
result = requests.get("https://ocr.captchaai.com/res.php", params={
"key": self.api_key,
"action": "get",
"id": task_id,
"json": 1
})
data = result.json()
if data["status"] == 1:
return data["request"]
raise TimeoutError("reCAPTCHA solve timed out")
def _parse_courses(self, html):
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, "html.parser")
def text_or_empty(node):
return node.text.strip() if node and node.text else ""
courses = []
for row in soup.select(".course-row, tr.course"):
courses.append({
"id": row.get("data-course-id", ""),
"department": text_or_empty(row.select_one(".dept")),
"number": text_or_empty(row.select_one(".number")),
"title": text_or_empty(row.select_one(".title")),
"seats": text_or_empty(row.select_one(".seats"))
})
return courses
def _parse_availability(self, html):
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, "html.parser")
def text_or_none(node):
return node.text.strip() if node and node.text else None
return {
"total_seats": text_or_none(soup.select_one(".total-seats")),
"enrolled": text_or_none(soup.select_one(".enrolled-count")),
"available": text_or_none(soup.select_one(".available-seats")),
"waitlist": text_or_none(soup.select_one(".waitlist-count"))
}
def _extract_error(self, html):
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, "html.parser")
error = soup.select_one(".error-message, .alert-danger")
return error.text.strip() if error else None
Executor do conjunto de testes (JavaScript)
class RegistrationTestSuite {
constructor(apiKey, portalUrl) {
this.apiKey = apiKey;
this.portalUrl = portalUrl;
this.results = [];
}
async runAll(testCredentials) {
const tests = [
() => this.testLogin(testCredentials),
() => this.testCourseSearch('Fall2025', 'CS'),
() => this.testEnrollment('CS101', '001'),
() => this.testDropCourse('CS101', '001'),
() => this.testWaitlistFlow('CS201', '001')
];
for (const test of tests) {
try {
const result = await test();
this.results.push({ ...result, passed: true });
} catch (error) {
this.results.push({ name: test.name, error: error.message, passed: false });
}
}
return this.generateReport();
}
async solveRecaptcha(pageUrl, html) {
const match = html.match(/data-sitekey="([^"]+)"/);
if (!match) return null;
const submitResp = await fetch('https://ocr.captchaai.com/in.php', {
method: 'POST',
body: new URLSearchParams({
key: this.apiKey,
method: 'userrecaptcha',
googlekey: match[1],
pageurl: pageUrl,
json: '1'
})
});
const { request: taskId } = await submitResp.json();
for (let i = 0; i < 60; i++) {
await new Promise(r => setTimeout(r, 3000));
const result = await fetch(
`https://ocr.captchaai.com/res.php?key=${this.apiKey}&action=get&id=${taskId}&json=1`
);
const data = await result.json();
if (data.status === 1) return data.request;
}
throw new Error('reCAPTCHA solve timed out');
}
generateReport() {
const passed = this.results.filter(r => r.passed).length;
const failed = this.results.filter(r => !r.passed).length;
return {
total: this.results.length,
passed,
failed,
passRate: `${((passed / this.results.length) * 100).toFixed(1)}%`,
details: this.results
};
}
}
// Usage
const suite = new RegistrationTestSuite('YOUR_API_KEY', 'https://register.university.edu');
const report = await suite.runAll({ studentId: 'test123', password: 'testpass' });
console.log(`Tests: ${report.passed}/${report.total} passed (${report.passRate})`);
Cenários de teste que acionam CAPTCHAs
| Cenário de teste | Frequência CAPTCHA | Impacto |
|---|---|---|
| Faça login com várias contas | Alto | Cada tentativa de login aciona o CAPTCHA |
| Testes de inscrição simultâneos | Alto | Proteção anti-bot |
| Pesquisas rápidas de cursos | Moderado | Consultas com taxa limitada |
| Geração de cronograma | Baixo | Interação de sessão única |
| Validação de pré-requisito | Baixo | Parte do fluxo de inscrição |
Solução de problemas
| Problema | Causa | Correção |
|---|---|---|
| CAPTCHA em cada login de teste | Sem reutilização de sessão | Autentique uma vez, execute testes dentro da sessão |
| A inscrição falha após CAPTCHA | O token CSRF expirou | Extraia novo token CSRF com CAPTCHA |
| Testar redefinições de dados entre execuções | Portal libera inscrições de testes | Use ambiente de teste dedicado |
| Chave do site reCAPTCHA não encontrada | SPA renderiza CAPTCHA dinamicamente | Use a automação do navegador para acessar o DOM renderizado |
Perguntas frequentes
Devo usar um ambiente de teste sem CAPTCHAs?
Idealmente, os ambientes de teste desativam os CAPTCHAs. Quando isso não for possível (ou ao testar o comportamento da produção), o CaptchaAI lida com a resolução do reCAPTCHA v2 para que os testes sejam executados sem intervenção manual.
Como lidar com CAPTCHAs em pipelines de teste CI/CD?
Adicione CaptchaAI como dependência de teste. Quando um teste encontrar um CAPTCHA, resolva-o por meio da API e continue. Isso mantém os testes confiáveis de ponta a ponta sem desativar os recursos de segurança.
Posso testar o registro sob carga com CAPTCHAs?
Sim. CaptchaAI lida com solução reCAPTCHA paralela para testes de carga. Envie várias solicitações de resolução simultaneamente para cada sessão simulada de aluno.
Artigos relacionados
- Como resolver o retorno de chamada do Recaptcha V2 usando API
- Torniquete Recaptcha V2 no mesmo local
- Mecanismo de retorno de chamada Recaptcha V2
Próximas etapas
Testar sistemas de registro de ponta a ponta -obtenha sua chave API CaptchaAIe lidar com CAPTCHAs de portais universitários em seu conjunto de testes.
