payload = {
    "nome": product_name,
    "preco": 250,
    "descricao": "Produto de teste",
    "quantidade": 10
}

@pytest.fixture
def api_request(playwright_instance: Playwright):
    request_context = playwright_instance.request.new_context(base_url=BASE_URL)
    yield request_context
    request_context.dispose()

def create_user(request: APIRequestContext, email: str, password: str, admin: bool):
    pass

import pytest
from playwright.sync_api import Playwright, sync_playwright

BASE_URL = "https://serverest.dev"

@pytest.fixture(scope="session")
def playwright_instance() -> Playwright:
    with sync_playwright() as playwright:
        yield playwright

@pytest.fixture
def api_request(playwright_instance: Playwright):
    request_context = playwright_instance.request.new_context(base_url=BASE_URL)
    yield request_context
    request_context.dispose()

import allure
from assertpy import assert_that
from playwright.sync_api import APIRequestContext
from tests.utils.api_utils import post_json, parse_response_body

@allure.severity(allure.severity_level.CRITICAL)
def test_ct01_login_with_valid_credentials_and_validate_token(api_request: APIRequestContext):
    email = "usuario_valido@email.com"
    password = "SenhaSegura@123"

    login_resp = post_json(api_request, "/login", {"email": email, "password": password})

    assert_that(login_resp.status).is_equal_to(200)
    body = parse_response_body(login_resp)
    assert_that(body["message"]).is_equal_to("Login realizado com sucesso")
    assert_that(body.get("authorization")).is_not_none()

@allure.severity(allure.severity_level.CRITICAL)
def test_ct02_login_with_invalid_credentials(api_request: APIRequestContext):
    resp = post_json(
        api_request,
        "/login",
        {
            "email": "usuario@inexistente.com",
            "password": "senhaerrada",
        },
    )

    assert_that(resp.status).is_equal_to(401)
    response_body = parse_response_body(resp)
    assert_that(response_body["message"]).is_equal_to("Email e/ou senha inválidos")

@allure.severity(allure.severity_level.NORMAL)
@pytest.mark.parametrize("_row", load_required_fields_rows())
def test_ct03_validate_required_fields_on_login(_row: dict[str, str], api_request: APIRequestContext):
    resp = post_json(api_request, "/login", {"email": "", "password": "senha123"})
    assert_that(resp.status).is_equal_to(400)
    body = parse_response_body(resp)
    assert_that(body.get("email")).is_not_none()

@allure.severity(allure.severity_level.CRITICAL)
def test_ct04_login_and_use_token_in_protected_route(api_request: APIRequestContext):
    auth_token = "Bearer XXXX"  # Recebido de requests anteriores do setup

    product_payload = {"nome": "Teste", "preco": 100, "descricao": "Teste", "quantidade": 10}

    product_resp = api_request.post(
        "/produtos",
        headers={**JSON_HEADERS, "Authorization": auth_token},
        data=json.dumps(product_payload, ensure_ascii=False),
    )

    assert_that(product_resp.status).is_equal_to(403)
    body = parse_response_body(product_resp)
    assert_that(body["message"]).is_equal_to("Rota exclusiva para administradores")

from pathlib import Path
import csv

def load_invalid_email_values() -> list[str]:
    csv_path = Path("tests/resources/login/invalid-login-emails.csv")
    with csv_path.open(encoding="utf-8") as f:
        return [row["email"] for row in csv.DictReader(f)]

@allure.severity(allure.severity_level.NORMAL)
@pytest.mark.parametrize("invalid_email", load_invalid_email_values())
def test_ct05_validate_invalid_email_format(invalid_email: str, api_request: APIRequestContext):
    resp = post_json(api_request, "/login", {"email": invalid_email, "password": "senha123"})

    assert_that(resp.status).is_equal_to(400)
    body = parse_response_body(resp)
    assert_that(body.get("email")).is_not_none()

import json
import os
from pathlib import Path

import allure
from assertpy import assert_that
from dotenv import load_dotenv
from playwright.sync_api import APIRequestContext
from tests.utils.api_utils import JSON_HEADERS, parse_response_body, post_json
from tests.utils.faker_utils import random_email, random_product

load_dotenv(Path(__file__).resolve().parents[2] / "user.env")
USER_PASSWORD = os.getenv("USER_PASSWORD")

@allure.severity(allure.severity_level.CRITICAL)
def test_ct01_full_cart_lifecycle_for_authenticated_user(api_request: APIRequestContext):
    # Criar usuário admin e obter token
    user_email = random_email()
    post_json(api_request, "/usuarios", {"nome": "Cart User", "email": user_email,
                                          "password": USER_PASSWORD, "administrador": "true"})
    login_resp = post_json(api_request, "/login", {"email": user_email, "password": USER_PASSWORD})
    assert_that(login_resp.status).is_equal_to(200)
    token = parse_response_body(login_resp)["authorization"]

    # Garantir que não há carrinho ativo
    api_request.delete("/carrinhos/cancelar-compra", headers={"Authorization": token})

    # Criar produto
    product_resp = api_request.post(
        "/produtos",
        headers={**JSON_HEADERS, "Authorization": token},
        data=json.dumps({"nome": random_product(), "preco": 150,
                         "descricao": "Produto de teste", "quantidade": 10}, ensure_ascii=False),
    )
    assert_that(product_resp.status).is_equal_to(201)
    product_id = parse_response_body(product_resp)["_id"]

    # Criar carrinho
    create_cart_resp = api_request.post(
        "/carrinhos",
        headers={**JSON_HEADERS, "Authorization": token},
        data=json.dumps({"produtos": [{"idProduto": product_id, "quantidade": 2}]}, ensure_ascii=False),
    )
    assert_that(create_cart_resp.status).is_equal_to(201)
    cart_id = parse_response_body(create_cart_resp)["_id"]

    # Buscar carrinho por ID e validar campos
    get_cart_resp = api_request.get(f"/carrinhos/{cart_id}")
    assert_that(get_cart_resp.status).is_equal_to(200)
    cart_body = parse_response_body(get_cart_resp)
    assert_that(cart_body["_id"]).is_equal_to(cart_id)
    assert_that(cart_body.get("precoTotal")).is_not_none()
    assert_that(cart_body.get("quantidadeTotal")).is_not_none()
    assert_that(len(cart_body["produtos"])).is_equal_to(1)

    # Concluir compra
    conclude_resp = api_request.delete("/carrinhos/concluir-compra", headers={"Authorization": token})
    assert_that(conclude_resp.status).is_equal_to(200)
    assert_that(parse_response_body(conclude_resp)["message"]).contains("Registro excluído com sucesso")

from assertpy import assert_that

from assertpy import assert_that
from tests.utils.api_utils import parse_response_body

resp = api_request.get("/usuarios")
assert_that(resp.status).is_equal_to(200)

body = parse_response_body(resp)
assert_that(body.get("quantidade")).is_greater_than(0)
assert_that(body.get("usuarios")).is_not_empty()

assert_that(body["message"]) \
    .is_not_none() \
    .contains("sucesso")

body = parse_response_body(resp)
assert_that(body).snapshot()   # cria ou valida __snapshots/<nome>.json

import os
from pathlib import Path
from dotenv import load_dotenv

# Sobe 2 níveis a partir de tests/carts/ até a raiz do projeto
load_dotenv(Path(__file__).resolve().parents[2] / "user.env")

USER_PASSWORD = os.getenv("USER_PASSWORD")

new_user = {
    "nome": "Cart User",
    "email": user_email,
    "password": USER_PASSWORD,
    "administrador": "true",
}

post_json(request, "/usuarios", new_user)
resp = post_json(request, "/login", {"email": user_email, "password": USER_PASSWORD})

USER_PASSWORD = os.getenv("USER_PASSWORD", "SenhaSegura@123")

request_context = playwright_instance.request.new_context(base_url="https://serverest.dev")

response = request.post(
    "/login",
    headers={"Content-Type": "application/json"},
    data={"email": email, "password": password}
)

body_json = response.json()
authorization_token = body_json.get("authorization")
http_status = response.status

import allure

# Context manager — passo nomeado no relatório
with allure.step("Criar usuário administrador"):
    post_json(request, "/usuarios", new_user)

# Decorator — reutilizável em funções helper
@allure.step("Fazer login e obter token")
def get_token(request, email, password):
    resp = post_json(request, "/login", {"email": email, "password": password})
    return parse_response_body(resp)["authorization"]

import allure
from assertpy import assert_that
from playwright.sync_api import APIRequestContext
from tests.utils.api_utils import post_json, parse_response_body

@allure.epic("Autenticação")
@allure.feature("Login")
@allure.story("Login com credenciais inválidas")
@allure.severity(allure.severity_level.CRITICAL)
@allure.title("CT02 - Login com credenciais inválidas retorna 401")
@allure.description("Valida que o endpoint retorna 401 para credencial incorreta de usuário")
@allure.tag("smoke", "regression")
@allure.issue("https://github.com/ServeRest/ServeRest/issues/1", name="SRV-123")
def test_ct02_login_with_invalid_credentials(api_request: APIRequestContext):
    with allure.step("Realizar POST com credencial incorreta"):
        resp = post_json(api_request, "/login", {"email": "usuario@inexistente.com", "password": "senhaerrada"})

    with allure.step("Validar status 401 e mensagem de erro"):
        assert_that(resp.status).is_equal_to(401)
        body = parse_response_body(resp)
        assert_that(body["message"]).is_equal_to("Email e/ou senha inválidos")