import pytest
import allure

@allure.epic("API Testing")
@allure.feature("User Management")
@pytest.mark.api
class TestMyAPI:

    @allure.title("Test GET endpoint")
    @allure.description("Verify that the API returns user list correctly")
    @allure.severity(allure.severity_level.CRITICAL)
    def test_get_endpoint(self, api_client, api_base_url):
        with allure.step("Send GET request to /users endpoint"):
            response = api_client.get(f"{api_base_url}/users")

        with allure.step("Verify response status code"):
            assert response.status_code == 200

        with allure.step("Verify response contains users"):
            users = response.json()
            assert len(users) > 0
            assert 'id' in users[0]
            assert 'username' in users[0]

    @allure.title("Test POST endpoint - Create user")
    def test_create_user(self, api_client, api_base_url):
        new_user = {
            "username": "testuser",
            "email": "test@example.com",
            "first_name": "Test",
            "last_name": "User"
        }

        with allure.step("Send POST request to create user"):
            response = api_client.post(f"{api_base_url}/users", json=new_user)

        with allure.step("Verify user creation was successful"):
            assert response.status_code == 201
            created_user = response.json()
            assert created_user['username'] == new_user['username']
            assert 'id' in created_user

    @allure.title("Test error handling - Invalid data")
    def test_invalid_data(self, api_client, api_base_url):
        with allure.step("Send request with invalid data"):
            response = api_client.post(f"{api_base_url}/users", json={})

        with allure.step("Verify API returns error"):
            assert response.status_code in [400, 422]

import pytest
import allure
from playwright.sync_api import Page, expect

@allure.epic("UI Testing")
@allure.feature("Web Navigation")
@pytest.mark.ui
class TestMyUI:

    @allure.title("Test page navigation")
    @allure.description("Verify page loads correctly and title is displayed")
    @allure.severity(allure.severity_level.CRITICAL)
    def test_navigation(self, page: Page):
        with allure.step("Navigate to homepage"):
            page.goto("https://example.com")
            expect(page).to_have_title("Example Domain")

        with allure.step("Verify page elements are visible"):
            expect(page.locator("h1")).to_be_visible()

        with allure.step("Capture screenshot"):
            allure.attach(
                page.screenshot(),
                name="Page Loaded",
                attachment_type=allure.attachment_type.PNG
            )

    @allure.title("Test form interaction")
    def test_form_interaction(self, page: Page):
        with allure.step("Navigate to form page"):
            page.goto("https://example.com/form")

        with allure.step("Fill out form fields"):
            page.fill("#username", "testuser")
            page.fill("#email", "test@example.com")

        with allure.step("Submit form"):
            page.click("button[type='submit']")

        with allure.step("Verify success message"):
            expect(page.locator(".success-message")).to_be_visible()
            allure.attach(
                page.screenshot(),
                name="Form Submitted",
                attachment_type=allure.attachment_type.PNG
            )

    @allure.title("Test responsive design - Mobile")
    def test_mobile_view(self, page: Page):
        with allure.step("Set mobile viewport"):
            page.set_viewport_size({"width": 375, "height": 667})

        with allure.step("Navigate to page"):
            page.goto("https://example.com")

        with allure.step("Verify mobile menu is visible"):
            expect(page.locator(".mobile-menu")).to_be_visible()

# Navigation
page.goto("https://example.com")
page.go_back()
page.reload()

# Interactions
page.click("button")
page.fill("input[name='email']", "test@test.com")
page.select_option("select", "option-value")
page.check("input[type='checkbox']")

# Assertions
expect(page.locator("h1")).to_have_text("Welcome")
expect(page).to_have_url("https://example.com/success")
expect(page.locator("button")).to_be_enabled()

# Waits
page.wait_for_selector(".loading", state="hidden")
page.wait_for_load_state("networkidle")

import pytest
import allure
import requests
import time

@allure.epic("Database Testing")
@allure.feature("User Management")
@pytest.mark.database
class TestMyDatabase:

    @allure.title("Test user CRUD operations")
    @allure.description("Verify complete CRUD workflow for user management")
    @allure.severity(allure.severity_level.CRITICAL)
    def test_user_crud(self, mock_server_url):
        # Create
        with allure.step("Create new user"):
            new_user = {
                "username": "john_doe",
                "email": "john@example.com",
                "first_name": "John",
                "last_name": "Doe"
            }
            response = requests.post(
                f"{mock_server_url}/api/users",
                json=new_user
            )
            assert response.status_code == 201
            user = response.json()
            user_id = user['id']
            assert user['username'] == new_user['username']

        # Read
        with allure.step("Fetch created user"):
            response = requests.get(f"{mock_server_url}/api/users/{user_id}")
            assert response.status_code == 200
            fetched_user = response.json()
            assert fetched_user['username'] == 'john_doe'
            assert fetched_user['email'] == 'john@example.com'

        # Update
        with allure.step("Update user information"):
            update_data = {
                "first_name": "Jonathan",
                "last_name": "Doe-Smith"
            }
            response = requests.put(
                f"{mock_server_url}/api/users/{user_id}",
                json=update_data
            )
            assert response.status_code == 200

        with allure.step("Verify update was successful"):
            response = requests.get(f"{mock_server_url}/api/users/{user_id}")
            updated_user = response.json()
            assert updated_user['first_name'] == "Jonathan"
            assert updated_user['last_name'] == "Doe-Smith"

        # Delete
        with allure.step("Delete user"):
            response = requests.delete(f"{mock_server_url}/api/users/{user_id}")
            assert response.status_code == 200

        with allure.step("Verify user was deleted"):
            response = requests.get(f"{mock_server_url}/api/users/{user_id}")
            assert response.status_code == 404

    @allure.title("Test data validation")
    def test_data_validation(self, mock_server_url):
        with allure.step("Attempt to create user with invalid email"):
            invalid_user = {
                "username": "testuser",
                "email": "not-an-email"
            }
            response = requests.post(
                f"{mock_server_url}/api/users",
                json=invalid_user
            )
            assert response.status_code in [400, 422]

        with allure.step("Attempt to create user with duplicate username"):
            response = requests.post(
                f"{mock_server_url}/api/users",
                json={"username": "admin", "email": "new@example.com"}
            )
            # Should either reject or handle gracefully
            assert response.status_code in [200, 201, 409]

    @allure.title("Test query performance")
    def test_query_performance(self, mock_server_url):
        with allure.step("Fetch all users and measure response time"):
            start_time = time.time()
            response = requests.get(f"{mock_server_url}/api/users")
            elapsed_time = time.time() - start_time

            assert response.status_code == 200
            assert elapsed_time < 0.5  # Should respond in under 500ms

            allure.attach(
                f"Query time: {elapsed_time:.3f}s",
                name="Performance Metrics",
                attachment_type=allure.attachment_type.TEXT
            )

        with allure.step("Test pagination performance"):
            start_time = time.time()
            response = requests.get(
                f"{mock_server_url}/api/users",
                params={"page": 1, "limit": 10}
            )
            elapsed_time = time.time() - start_time

            assert response.status_code == 200
            assert elapsed_time < 0.3  # Paginated query should be faster

    @allure.title("Test concurrent operations")
    def test_concurrent_operations(self, mock_server_url):
        import concurrent.futures

        def create_user(index):
            return requests.post(
                f"{mock_server_url}/api/users",
                json={
                    "username": f"user_{index}",
                    "email": f"user{index}@example.com"
                }
            )

        with allure.step("Create 10 users concurrently"):
            with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
                futures = [executor.submit(create_user, i) for i in range(10)]
                responses = [f.result() for f in concurrent.futures.as_completed(futures)]

        with allure.step("Verify all users were created successfully"):
            successful = sum(1 for r in responses if r.status_code == 201)
            assert successful >= 8  # Allow some failures in concurrent scenario

# Testing relationships
def test_user_orders(mock_server_url):
    user = create_test_user(mock_server_url)
    order = create_test_order(mock_server_url, user['id'])

    # Verify relationship
    orders = get_user_orders(mock_server_url, user['id'])
    assert len(orders) == 1
    assert orders[0]['id'] == order['id']

# Testing transactions
def test_transaction_rollback(mock_server_url):
    # This would require direct DB access or special endpoints
    # to test transaction handling
    pass

# Testing data integrity
def test_cascade_delete(mock_server_url):
    user = create_test_user(mock_server_url)
    create_test_order(mock_server_url, user['id'])

    # Delete user
    delete_user(mock_server_url, user['id'])

    # Verify orders were also deleted (cascade)
    orders = get_user_orders(mock_server_url, user['id'])
    assert len(orders) == 0

# tests/conftest.py
@pytest.fixture(scope='session')
def mock_server_url():
    # Change this to your real API URL
    return "https://your-api.example.com"

# config/database.py
import os

DATABASE_CONFIG = {
    'host': os.getenv('DB_HOST', 'localhost'),
    'port': int(os.getenv('DB_PORT', '5432')),
    'database': os.getenv('DB_NAME', 'test_db'),
    'user': os.getenv('DB_USER', 'postgres'),
    'password': os.getenv('DB_PASSWORD', 'your_password')
}

# tests/conftest.py
import psycopg2
from config.database import DATABASE_CONFIG

@pytest.fixture(scope='session')
def db_connection():
    conn = psycopg2.connect(**DATABASE_CONFIG)
    yield conn
    conn.close()

@pytest.fixture
def db_cursor(db_connection):
    cursor = db_connection.cursor()
    yield cursor
    db_connection.rollback()  # Cleanup after each test
    cursor.close()

def test_direct_query(db_cursor):
    db_cursor.execute("SELECT COUNT(*) FROM users")
    count = db_cursor.fetchone()[0]
    assert count > 0