AI ile Test Yazımı ve Otomasyon

Bu sayfada

AI ile Test Yazımı ve Otomasyon Prompt Şablonları

Bu rehber, yapay zeka kullanarak etkili testler yazmak, test coverage ı artırmak ve test otomasyon süreçlerini hızlandırmak için tasarlanmış kapsamlı prompt şablonlarını içermektedir. Unit testlerden E2E testlere, API testlerinden performans testlerine kadar geniş bir yelpazede kullanabileceğiniz şablonlar sunulmaktadır.

🧪 Kullanım Notu: Şablonlardaki [KÖŞELİ PARANTEZ] içindeki alanları kendi projenize göre doldurun. AI tarafından üretilen testleri mutlaka çalıştırın ve doğrulayın. Test mantığının doğruluğunu kontrol edin, AI bazen yanlış assertion lar üretebilir.

Unit Test Şablonları

Genel Unit Test Üretimi

Fonksiyon veya metod için unit test yazmak.

Bu kod için unit testler yaz.



KOD:

[Test edilecek kodu yapıştır]



TEST BİLGİLERİ:

Programlama dili: [Python / JavaScript / TypeScript / Java / C# / Go]

Test framework: [pytest / unittest / Jest / Mocha / JUnit / NUnit / xUnit]

Mocking library: [unittest.mock / Jest mocks / Mockito / Moq]

Coverage hedefi: [%80 / %90 / %100]



TEST GEREKSİNİMLERİ:



1. NORMAL CASES (Happy Path):

   Beklenen girdilerle doğru çalışma



2. EDGE CASES:

   Sınır değerler ve özel durumlar



3. ERROR CASES:

   Hata durumları ve exception handling



4. BOUNDARY CASES:

   Min/max değerler, boş girdiler



TEST YAPISI:

Arrange-Act-Assert pattern kullan

Her test tek bir şeyi test etsin

Descriptive test isimleri kullan

Test isolation sağla



ÇIKTI FORMATI:



[Test dosyası başlangıcı]



[Import statements]



[Test class veya describe block]



[Her test case için]

Test adı: test_[ne_test_ediliyor]_[beklenen_sonuc]

Açıklama: [Bu test ne kontrol ediyor]

Arrange: [Setup]

Act: [Çalıştırma]

Assert: [Doğrulama]



[Test dosyası sonu]

Python pytest Şablonu

Python projelerinde pytest ile test yazmak için.

Bu Python fonksiyonu için pytest testleri yaz.



FONKSİYON:

[Python kodunu yapıştır]



PYTEST ÖZELLİKLERİ:

Fixtures kullan: [Evet / Hayır]

Parametrize kullan: [Evet / Hayır]

Markers kullan: [Evet / Hayır]

Async testler: [Evet / Hayır]



ÖRNEK ÇIKTI YAPISI:



import pytest

from unittest.mock import Mock, patch, MagicMock

from [module] import [function_name]



# Fixtures

@pytest.fixture

def sample_data():

    """Test için örnek veri sağlar."""

    return {

        "id": 1,

        "name": "test",

        "values": [1, 2, 3]

    }



@pytest.fixture

def mock_database():

    """Mock database bağlantısı."""

    with patch("module.database") as mock_db:

        mock_db.query.return_value = []

        yield mock_db



# Normal Case Tests

class TestFunctionNameHappyPath:

    """Başarılı senaryolar için testler."""

    

    def test_valid_input_returns_expected_result(self, sample_data):

        """Geçerli girdi ile beklenen sonucu döndürür."""

        result = function_name(sample_data)

        

        assert result is not None

        assert result["status"] == "success"

    

    @pytest.mark.parametrize("input_value,expected", [

        (1, "one"),

        (2, "two"),

        (3, "three"),

    ])

    def test_multiple_valid_inputs(self, input_value, expected):

        """Farklı geçerli girdiler için doğru sonuç."""

        result = function_name(input_value)

        assert result == expected



# Edge Case Tests

class TestFunctionNameEdgeCases:

    """Sınır durumları için testler."""

    

    def test_empty_input_returns_empty_result(self):

        """Boş girdi için boş sonuç döndürür."""

        result = function_name([])

        assert result == []

    

    def test_none_input_returns_none(self):

        """None girdi için None döndürür."""

        result = function_name(None)

        assert result is None

    

    def test_maximum_value_handled_correctly(self):

        """Maksimum değer doğru işlenir."""

        result = function_name(sys.maxsize)

        assert result is not None



# Error Case Tests

class TestFunctionNameErrors:

    """Hata durumları için testler."""

    

    def test_invalid_type_raises_type_error(self):

        """Geçersiz tip TypeError fırlatır."""

        with pytest.raises(TypeError) as exc_info:

            function_name("invalid")

        

        assert "expected int" in str(exc_info.value)

    

    def test_negative_value_raises_value_error(self):

        """Negatif değer ValueError fırlatır."""

        with pytest.raises(ValueError, match="must be positive"):

            function_name(-1)



# Mock Tests

class TestFunctionNameWithMocks:

    """External dependency mockları ile testler."""

    

    def test_calls_external_service_correctly(self, mock_database):

        """External servis doğru parametrelerle çağrılır."""

        function_name("test_id")

        

        mock_database.query.assert_called_once_with("test_id")

    

    @patch("module.external_api")

    def test_handles_api_failure_gracefully(self, mock_api):

        """API hatası gracefully handle edilir."""

        mock_api.call.side_effect = ConnectionError("API down")

        

        result = function_name("test")

        

        assert result["status"] == "fallback"

JavaScript Jest Şablonu

JavaScript/TypeScript projelerinde Jest ile test yazmak için.

Bu JavaScript/TypeScript kodu için Jest testleri yaz.



KOD:

[JS/TS kodunu yapıştır]



JEST ÖZELLİKLERİ:

TypeScript: [Evet / Hayır]

React Testing Library: [Evet / Hayır]

Async testler: [Evet / Hayır]

Snapshot testler: [Evet / Hayır]



ÖRNEK ÇIKTI YAPISI:



import { functionName } from "./module";

import { someService } from "./services";



// Mock setup

jest.mock("./services");

const mockService = someService as jest.MockedFunction<typeof someService>;



describe("functionName", () => {

    // Setup and teardown

    beforeEach(() => {

        jest.clearAllMocks();

    });



    afterEach(() => {

        jest.resetAllMocks();

    });



    describe("happy path", () => {

        it("should return expected result for valid input", () => {

            // Arrange

            const input = { id: 1, name: "test" };

            const expected = { success: true, data: input };



            // Act

            const result = functionName(input);



            // Assert

            expect(result).toEqual(expected);

        });



        it("should handle multiple items correctly", () => {

            const items = [1, 2, 3];

            

            const result = functionName(items);

            

            expect(result).toHaveLength(3);

            expect(result[0]).toBe(1);

        });

    });



    describe("edge cases", () => {

        it("should return empty array for empty input", () => {

            const result = functionName([]);

            

            expect(result).toEqual([]);

        });



        it("should handle null input gracefully", () => {

            const result = functionName(null);

            

            expect(result).toBeNull();

        });



        it("should handle undefined input", () => {

            const result = functionName(undefined);

            

            expect(result).toBeUndefined();

        });

    });



    describe("error cases", () => {

        it("should throw TypeError for invalid input type", () => {

            expect(() => functionName("invalid")).toThrow(TypeError);

        });



        it("should throw specific error message", () => {

            expect(() => functionName(-1)).toThrow("Value must be positive");

        });

    });



    describe("async operations", () => {

        it("should resolve with data on success", async () => {

            mockService.mockResolvedValue({ data: "test" });



            const result = await functionName("id");



            expect(result.data).toBe("test");

        });



        it("should reject on service failure", async () => {

            mockService.mockRejectedValue(new Error("Service error"));



            await expect(functionName("id")).rejects.toThrow("Service error");

        });

    });



    describe("with mocks", () => {

        it("should call service with correct parameters", () => {

            functionName("test-id");



            expect(mockService).toHaveBeenCalledWith("test-id");

            expect(mockService).toHaveBeenCalledTimes(1);

        });

    });

});

Test Case Üretimi

Fonksiyon için test case listesi oluşturmak.

Bu fonksiyon için kapsamlı test case listesi oluştur.



FONKSİYON:

[Fonksiyon imzası veya kodu]



FONKSİYON AÇIKLAMASI:

[Ne yapar, parametreler, dönüş değeri]



TEST CASE KATEGORİLERİ:



1. NORMAL CASES (Pozitif Testler):

Geçerli girdilerle beklenen davranış



Test ID | Açıklama | Input | Expected Output | Öncelik

TC001 | [Açıklama] | [Input] | [Output] | Yüksek

TC002 | [Açıklama] | [Input] | [Output] | Yüksek



2. EDGE CASES (Sınır Testleri):

Sınır değerleri ve özel durumlar



Test ID | Açıklama | Input | Expected Output | Öncelik

TC010 | Boş input | [] | [] | Yüksek

TC011 | Tek eleman | [1] | [1] | Orta

TC012 | Maksimum boyut | [1..10000] | [...] | Orta



3. BOUNDARY CASES (Sınır Değer Testleri):

Min/max sınırları



Test ID | Açıklama | Input | Expected Output | Öncelik

TC020 | Minimum değer | 0 | [...] | Yüksek

TC021 | Maksimum değer | MAX_INT | [...] | Yüksek

TC022 | Sınırın bir altı | -1 | Error | Yüksek

TC023 | Sınırın bir üstü | MAX+1 | Error | Yüksek



4. ERROR CASES (Negatif Testler):

Hata durumları ve exception lar



Test ID | Açıklama | Input | Expected Error | Öncelik

TC030 | Null input | null | NullError | Kritik

TC031 | Yanlış tip | "string" | TypeError | Kritik

TC032 | Geçersiz format | {invalid} | FormatError | Yüksek



5. SPECIAL CASES (Özel Durumlar):

Özel karakterler, unicode, vb.



Test ID | Açıklama | Input | Expected Output | Öncelik

TC040 | Unicode karakterler | "日本語" | [...] | Orta

TC041 | Özel karakterler | "!@#$%" | [...] | Orta

TC042 | Çok uzun string | "a"*10000 | [...] | Düşük



6. PERFORMANCE CASES (Performans Testleri):

Büyük veri ve yük testleri



Test ID | Açıklama | Input Size | Max Time | Öncelik

TC050 | Büyük veri seti | 1M kayıt | 5 saniye | Orta

TC051 | Concurrent erişim | 100 thread | 10 saniye | Orta



ÖZET:

Toplam test case: [X]

Kritik: [Y]

Yüksek öncelik: [Z]

Orta öncelik: [W]

Düşük öncelik: [V]

Integration Test Şablonları

API Integration Test

API endpoint larını test etmek için.

Bu API endpoint için integration test yaz.



API BİLGİLERİ:

Endpoint: [HTTP METHOD] [/api/path]

Framework: [Express / FastAPI / Spring Boot / .NET]

Test framework: [Supertest / pytest / RestAssured]

Database: [PostgreSQL / MongoDB / MySQL]



ENDPOINT AÇIKLAMASI:

[Endpoint ne yapar]



REQUEST:

Headers: [...]

Body: [...]

Query params: [...]



RESPONSE:

Success: [200/201] [Response body]

Error: [400/401/404/500] [Error body]



ÖRNEK ÇIKTI YAPISI (Python FastAPI + pytest):



import pytest

from httpx import AsyncClient

from sqlalchemy.orm import Session

from app.main import app

from app.models import User

from app.database import get_db, engine



# Test database setup

@pytest.fixture(scope="module")

def test_db():

    """Test database oluştur ve temizle."""

    Base.metadata.create_all(bind=engine)

    yield

    Base.metadata.drop_all(bind=engine)



@pytest.fixture

def db_session(test_db):

    """Her test için yeni session."""

    session = Session(engine)

    yield session

    session.rollback()

    session.close()



@pytest.fixture

def sample_user(db_session):

    """Test için örnek kullanıcı."""

    user = User(email="test@example.com", name="Test User")

    db_session.add(user)

    db_session.commit()

    return user



@pytest.fixture

def auth_headers(sample_user):

    """Authentication headers."""

    token = create_access_token(sample_user.id)

    return {"Authorization": f"Bearer {token}"}



# API Tests

class TestCreateUserEndpoint:

    """POST /api/users endpoint testleri."""

    

    @pytest.mark.asyncio

    async def test_create_user_success(self, db_session):

        """Geçerli veri ile kullanıcı oluşturma."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            payload = {

                "email": "new@example.com",

                "name": "New User",

                "password": "SecurePass123!"

            }

            

            response = await client.post("/api/users", json=payload)

            

            assert response.status_code == 201

            data = response.json()

            assert data["email"] == payload["email"]

            assert data["name"] == payload["name"]

            assert "id" in data

            assert "password" not in data

    

    @pytest.mark.asyncio

    async def test_create_user_duplicate_email(self, sample_user):

        """Duplicate email ile 409 Conflict."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            payload = {

                "email": sample_user.email,

                "name": "Another User",

                "password": "SecurePass123!"

            }

            

            response = await client.post("/api/users", json=payload)

            

            assert response.status_code == 409

            assert "already exists" in response.json()["detail"]

    

    @pytest.mark.asyncio

    async def test_create_user_invalid_email(self):

        """Geçersiz email formatı ile 422 Validation Error."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            payload = {

                "email": "invalid-email",

                "name": "Test",

                "password": "SecurePass123!"

            }

            

            response = await client.post("/api/users", json=payload)

            

            assert response.status_code == 422

    

    @pytest.mark.asyncio

    async def test_create_user_missing_required_field(self):

        """Zorunlu alan eksik ile 422."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            payload = {"email": "test@example.com"}

            

            response = await client.post("/api/users", json=payload)

            

            assert response.status_code == 422



class TestGetUserEndpoint:

    """GET /api/users/{id} endpoint testleri."""

    

    @pytest.mark.asyncio

    async def test_get_user_success(self, sample_user, auth_headers):

        """Var olan kullanıcıyı getirme."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            response = await client.get(

                f"/api/users/{sample_user.id}",

                headers=auth_headers

            )

            

            assert response.status_code == 200

            data = response.json()

            assert data["id"] == sample_user.id

    

    @pytest.mark.asyncio

    async def test_get_user_not_found(self, auth_headers):

        """Olmayan kullanıcı için 404."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            response = await client.get(

                "/api/users/99999",

                headers=auth_headers

            )

            

            assert response.status_code == 404

    

    @pytest.mark.asyncio

    async def test_get_user_unauthorized(self, sample_user):

        """Auth token olmadan 401."""

        async with AsyncClient(app=app, base_url="http://test") as client:

            response = await client.get(f"/api/users/{sample_user.id}")

            

            assert response.status_code == 401

Database Integration Test

Database işlemlerini test etmek için.

Bu database işlemi için integration test yaz.



DATABASE:

Tip: [PostgreSQL / MySQL / MongoDB / Redis]

ORM: [SQLAlchemy / Prisma / Mongoose / TypeORM]

İşlem: [CRUD / Transaction / Query]



KOD:

[Repository veya database kodunu yapıştır]



TEST GEREKSİNİMLERİ:

Test database kullan (production değil)

Her test sonrası temizlik yap

Transaction rollback kullan

Isolation sağla



ÖRNEK ÇIKTI YAPISI:



import pytest

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker

from app.repositories import UserRepository

from app.models import User, Base



# Test database configuration

TEST_DATABASE_URL = "postgresql://test:test@localhost/test_db"



@pytest.fixture(scope="session")

def engine():

    """Test database engine."""

    return create_engine(TEST_DATABASE_URL)



@pytest.fixture(scope="session")

def tables(engine):

    """Create tables once for all tests."""

    Base.metadata.create_all(engine)

    yield

    Base.metadata.drop_all(engine)



@pytest.fixture

def db_session(engine, tables):

    """Each test gets a fresh session with rollback."""

    connection = engine.connect()

    transaction = connection.begin()

    session = sessionmaker(bind=connection)()

    

    yield session

    

    session.close()

    transaction.rollback()

    connection.close()



@pytest.fixture

def user_repository(db_session):

    """UserRepository instance with test session."""

    return UserRepository(db_session)



class TestUserRepository:

    """UserRepository integration testleri."""

    

    def test_create_user(self, user_repository, db_session):

        """Kullanıcı oluşturma ve kaydetme."""

        user_data = {

            "email": "test@example.com",

            "name": "Test User",

            "password_hash": "hashed_password"

        }

        

        user = user_repository.create(user_data)

        

        assert user.id is not None

        assert user.email == user_data["email"]

        

        # Verify in database

        db_user = db_session.query(User).filter_by(id=user.id).first()

        assert db_user is not None

        assert db_user.email == user_data["email"]

    

    def test_get_by_id(self, user_repository, db_session):

        """ID ile kullanıcı getirme."""

        # Arrange

        user = User(email="test@example.com", name="Test")

        db_session.add(user)

        db_session.flush()

        

        # Act

        result = user_repository.get_by_id(user.id)

        

        # Assert

        assert result is not None

        assert result.id == user.id

    

    def test_get_by_id_not_found(self, user_repository):

        """Olmayan ID için None dönmeli."""

        result = user_repository.get_by_id(99999)

        

        assert result is None

    

    def test_update_user(self, user_repository, db_session):

        """Kullanıcı güncelleme."""

        user = User(email="test@example.com", name="Original")

        db_session.add(user)

        db_session.flush()

        

        updated = user_repository.update(user.id, {"name": "Updated"})

        

        assert updated.name == "Updated"

        db_session.refresh(user)

        assert user.name == "Updated"

    

    def test_delete_user(self, user_repository, db_session):

        """Kullanıcı silme."""

        user = User(email="test@example.com", name="ToDelete")

        db_session.add(user)

        db_session.flush()

        user_id = user.id

        

        result = user_repository.delete(user_id)

        

        assert result is True

        assert db_session.query(User).filter_by(id=user_id).first() is None

    

    def test_list_users_with_pagination(self, user_repository, db_session):

        """Sayfalama ile kullanıcı listesi."""

        for i in range(25):

            db_session.add(User(email=f"user{i}@example.com", name=f"User {i}"))

        db_session.flush()

        

        page1 = user_repository.list(page=1, per_page=10)

        page2 = user_repository.list(page=2, per_page=10)

        

        assert len(page1) == 10

        assert len(page2) == 10

        assert page1[0].id != page2[0].id

    

    def test_transaction_rollback_on_error(self, user_repository, db_session):

        """Hata durumunda transaction rollback."""

        initial_count = db_session.query(User).count()

        

        try:

            with db_session.begin_nested():

                user_repository.create({"email": "test@example.com", "name": "Test"})

                raise Exception("Simulated error")

        except Exception:

            pass

        

        final_count = db_session.query(User).count()

        assert final_count == initial_count

End-to-End Test Şablonları

Playwright E2E Test

Web uygulamaları için Playwright E2E testleri.

Bu web sayfası/akışı için Playwright E2E test yaz.



SAYFA/AKIŞ:

[Test edilecek sayfa veya kullanıcı akışını açıkla]



URL: [...]

Test framework: [Playwright / Cypress / Selenium]

Dil: [TypeScript / JavaScript / Python]



SENARYO:

[Kullanıcının yapacağı adımları listele]



ÖRNEK ÇIKTI YAPISI (Playwright + TypeScript):



import { test, expect, Page } from "@playwright/test";



// Test fixtures

test.describe("User Authentication Flow", () => {

    let page: Page;



    test.beforeEach(async ({ page: testPage }) => {

        page = testPage;

        await page.goto("/login");

    });



    test("successful login with valid credentials", async () => {

        // Fill login form

        await page.fill("[data-testid=email-input]", "user@example.com");

        await page.fill("[data-testid=password-input]", "ValidPass123!");

        

        // Click login button

        await page.click("[data-testid=login-button]");

        

        // Wait for navigation

        await page.waitForURL("/dashboard");

        

        // Verify successful login

        await expect(page.locator("[data-testid=welcome-message]")).toContainText("Welcome");

        await expect(page.locator("[data-testid=user-menu]")).toBeVisible();

    });



    test("shows error for invalid credentials", async () => {

        await page.fill("[data-testid=email-input]", "wrong@example.com");

        await page.fill("[data-testid=password-input]", "wrongpassword");

        await page.click("[data-testid=login-button]");

        

        // Verify error message

        await expect(page.locator("[data-testid=error-message]")).toBeVisible();

        await expect(page.locator("[data-testid=error-message]")).toContainText("Invalid credentials");

        

        // Should stay on login page

        await expect(page).toHaveURL("/login");

    });



    test("validates required fields", async () => {

        // Click login without filling form

        await page.click("[data-testid=login-button]");

        

        // Verify validation errors

        await expect(page.locator("[data-testid=email-error]")).toContainText("Email is required");

        await expect(page.locator("[data-testid=password-error]")).toContainText("Password is required");

    });



    test("validates email format", async () => {

        await page.fill("[data-testid=email-input]", "invalid-email");

        await page.fill("[data-testid=password-input]", "somepassword");

        await page.click("[data-testid=login-button]");

        

        await expect(page.locator("[data-testid=email-error]")).toContainText("Invalid email format");

    });

});



test.describe("Shopping Cart Flow", () => {

    test.beforeEach(async ({ page }) => {

        // Login before each test

        await page.goto("/login");

        await page.fill("[data-testid=email-input]", "user@example.com");

        await page.fill("[data-testid=password-input]", "ValidPass123!");

        await page.click("[data-testid=login-button]");

        await page.waitForURL("/dashboard");

    });



    test("add product to cart", async ({ page }) => {

        // Navigate to product page

        await page.goto("/products/123");

        

        // Add to cart

        await page.click("[data-testid=add-to-cart-button]");

        

        // Verify cart update

        await expect(page.locator("[data-testid=cart-count]")).toContainText("1");

        

        // Verify toast notification

        await expect(page.locator("[data-testid=toast]")).toContainText("Added to cart");

    });



    test("complete checkout process", async ({ page }) => {

        // Add product and go to cart

        await page.goto("/products/123");

        await page.click("[data-testid=add-to-cart-button]");

        await page.click("[data-testid=cart-icon]");

        

        // Proceed to checkout

        await page.click("[data-testid=checkout-button]");

        await page.waitForURL("/checkout");

        

        // Fill shipping info

        await page.fill("[data-testid=address-input]", "123 Test Street");

        await page.fill("[data-testid=city-input]", "Test City");

        await page.selectOption("[data-testid=country-select]", "US");

        

        // Fill payment info

        await page.fill("[data-testid=card-number]", "4111111111111111");

        await page.fill("[data-testid=card-expiry]", "12/25");

        await page.fill("[data-testid=card-cvv]", "123");

        

        // Complete order

        await page.click("[data-testid=place-order-button]");

        

        // Verify success

        await page.waitForURL(/\/order-confirmation\/\d+/);

        await expect(page.locator("[data-testid=order-success]")).toBeVisible();

    });



    test("handles out of stock product", async ({ page }) => {

        await page.goto("/products/out-of-stock-id");

        

        await expect(page.locator("[data-testid=add-to-cart-button]")).toBeDisabled();

        await expect(page.locator("[data-testid=stock-status]")).toContainText("Out of Stock");

    });

});



// Visual regression test

test("login page visual snapshot", async ({ page }) => {

    await page.goto("/login");

    await expect(page).toHaveScreenshot("login-page.png");

});



// Mobile responsive test

test.describe("Mobile responsiveness", () => {

    test.use({ viewport: { width: 375, height: 667 } });



    test("shows mobile menu on small screens", async ({ page }) => {

        await page.goto("/");

        

        await expect(page.locator("[data-testid=desktop-menu]")).toBeHidden();

        await expect(page.locator("[data-testid=mobile-menu-button]")).toBeVisible();

        

        await page.click("[data-testid=mobile-menu-button]");

        await expect(page.locator("[data-testid=mobile-menu]")).toBeVisible();

    });

});

Cypress E2E Test

Cypress ile E2E test yazmak için.

Bu kullanıcı akışı için Cypress E2E test yaz.



AKIŞ:

[Kullanıcı akışını açıkla]



ÖRNEK ÇIKTI YAPISI:



// cypress/e2e/user-registration.cy.ts



describe("User Registration", () => {

    beforeEach(() => {

        cy.visit("/register");

    });



    it("successfully registers a new user", () => {

        // Fill registration form

        cy.get("[data-cy=name-input]").type("John Doe");

        cy.get("[data-cy=email-input]").type("john@example.com");

        cy.get("[data-cy=password-input]").type("SecurePass123!");

        cy.get("[data-cy=confirm-password-input]").type("SecurePass123!");

        

        // Accept terms

        cy.get("[data-cy=terms-checkbox]").check();

        

        // Submit form

        cy.get("[data-cy=register-button]").click();

        

        // Verify redirect to dashboard

        cy.url().should("include", "/dashboard");

        

        // Verify welcome message

        cy.get("[data-cy=welcome-message]").should("contain", "Welcome, John");

    });



    it("shows validation errors for empty form", () => {

        cy.get("[data-cy=register-button]").click();

        

        cy.get("[data-cy=name-error]").should("be.visible");

        cy.get("[data-cy=email-error]").should("be.visible");

        cy.get("[data-cy=password-error]").should("be.visible");

    });



    it("shows error when passwords do not match", () => {

        cy.get("[data-cy=password-input]").type("Password123!");

        cy.get("[data-cy=confirm-password-input]").type("DifferentPass!");

        cy.get("[data-cy=register-button]").click();

        

        cy.get("[data-cy=confirm-password-error]")

            .should("contain", "Passwords do not match");

    });



    it("shows error for existing email", () => {

        // Intercept API call

        cy.intercept("POST", "/api/register", {

            statusCode: 409,

            body: { error: "Email already exists" }

        }).as("registerRequest");

        

        cy.get("[data-cy=name-input]").type("John Doe");

        cy.get("[data-cy=email-input]").type("existing@example.com");

        cy.get("[data-cy=password-input]").type("SecurePass123!");

        cy.get("[data-cy=confirm-password-input]").type("SecurePass123!");

        cy.get("[data-cy=terms-checkbox]").check();

        cy.get("[data-cy=register-button]").click();

        

        cy.wait("@registerRequest");

        cy.get("[data-cy=form-error]").should("contain", "Email already exists");

    });

});



// Custom commands

Cypress.Commands.add("login", (email: string, password: string) => {

    cy.session([email, password], () => {

        cy.visit("/login");

        cy.get("[data-cy=email-input]").type(email);

        cy.get("[data-cy=password-input]").type(password);

        cy.get("[data-cy=login-button]").click();

        cy.url().should("include", "/dashboard");

    });

});



// Using custom command

describe("Protected Routes", () => {

    beforeEach(() => {

        cy.login("user@example.com", "password123");

    });



    it("can access dashboard", () => {

        cy.visit("/dashboard");

        cy.get("[data-cy=dashboard-content]").should("be.visible");

    });

});

API Test Şablonları

REST API Test

REST API endpoint testleri için.

Bu REST API için test suite oluştur.



API ENDPOINT:

Method: [GET / POST / PUT / PATCH / DELETE]

URL: [/api/resource]

Auth: [Bearer Token / API Key / None]



REQUEST SPEC:

Headers: [...]

Body: [...]

Query params: [...]



RESPONSE SPEC:

Success codes: [200, 201]

Error codes: [400, 401, 403, 404, 500]



ÖRNEK ÇIKTI YAPISI (Python + requests + pytest):



import pytest

import requests

from typing import Dict, Any



BASE_URL = "http://localhost:8000/api"



class TestUsersAPI:

    """Users API endpoint testleri."""

    

    @pytest.fixture

    def auth_token(self) -> str:

        """Test için authentication token al."""

        response = requests.post(

            f"{BASE_URL}/auth/login",

            json={"email": "test@example.com", "password": "testpass"}

        )

        return response.json()["access_token"]

    

    @pytest.fixture

    def auth_headers(self, auth_token: str) -> Dict[str, str]:

        """Authorization headers."""

        return {"Authorization": f"Bearer {auth_token}"}

    

    @pytest.fixture

    def created_user(self, auth_headers) -> Dict[str, Any]:

        """Test için kullanıcı oluştur ve sonra temizle."""

        payload = {

            "email": "testuser@example.com",

            "name": "Test User",

            "role": "user"

        }

        response = requests.post(

            f"{BASE_URL}/users",

            json=payload,

            headers=auth_headers

        )

        user = response.json()

        yield user

        # Cleanup

        requests.delete(f"{BASE_URL}/users/{user['id']}", headers=auth_headers)



    # GET /users Tests

    class TestGetUsers:

        """GET /users endpoint testleri."""

        

        def test_get_users_success(self, auth_headers):

            """Kullanıcı listesi başarıyla döner."""

            response = requests.get(

                f"{BASE_URL}/users",

                headers=auth_headers

            )

            

            assert response.status_code == 200

            data = response.json()

            assert isinstance(data, list)

            assert "id" in data[0]

            assert "email" in data[0]

        

        def test_get_users_with_pagination(self, auth_headers):

            """Pagination parametreleri çalışır."""

            response = requests.get(

                f"{BASE_URL}/users",

                params={"page": 1, "per_page": 10},

                headers=auth_headers

            )

            

            assert response.status_code == 200

            data = response.json()

            assert len(data) <= 10

        

        def test_get_users_unauthorized(self):

            """Auth token olmadan 401 döner."""

            response = requests.get(f"{BASE_URL}/users")

            

            assert response.status_code == 401

    

    # POST /users Tests

    class TestCreateUser:

        """POST /users endpoint testleri."""

        

        def test_create_user_success(self, auth_headers):

            """Geçerli veri ile kullanıcı oluşturulur."""

            payload = {

                "email": "newuser@example.com",

                "name": "New User",

                "role": "user"

            }

            

            response = requests.post(

                f"{BASE_URL}/users",

                json=payload,

                headers=auth_headers

            )

            

            assert response.status_code == 201

            data = response.json()

            assert data["email"] == payload["email"]

            assert "id" in data

            assert "created_at" in data

            

            # Cleanup

            requests.delete(f"{BASE_URL}/users/{data['id']}", headers=auth_headers)

        

        def test_create_user_invalid_email(self, auth_headers):

            """Geçersiz email ile 422 döner."""

            payload = {

                "email": "invalid-email",

                "name": "Test",

                "role": "user"

            }

            

            response = requests.post(

                f"{BASE_URL}/users",

                json=payload,

                headers=auth_headers

            )

            

            assert response.status_code == 422

            errors = response.json()

            assert "email" in str(errors)

        

        def test_create_user_missing_required_field(self, auth_headers):

            """Zorunlu alan eksik ile 422 döner."""

            payload = {"name": "Test"}

            

            response = requests.post(

                f"{BASE_URL}/users",

                json=payload,

                headers=auth_headers

            )

            

            assert response.status_code == 422

        

        def test_create_user_duplicate_email(self, auth_headers, created_user):

            """Duplicate email ile 409 döner."""

            payload = {

                "email": created_user["email"],

                "name": "Another User",

                "role": "user"

            }

            

            response = requests.post(

                f"{BASE_URL}/users",

                json=payload,

                headers=auth_headers

            )

            

            assert response.status_code == 409

    

    # GET /users/{id} Tests

    class TestGetUserById:

        """GET /users/{id} endpoint testleri."""

        

        def test_get_user_success(self, auth_headers, created_user):

            """Var olan kullanıcı döner."""

            response = requests.get(

                f"{BASE_URL}/users/{created_user['id']}",

                headers=auth_headers

            )

            

            assert response.status_code == 200

            data = response.json()

            assert data["id"] == created_user["id"]

        

        def test_get_user_not_found(self, auth_headers):

            """Olmayan kullanıcı için 404 döner."""

            response = requests.get(

                f"{BASE_URL}/users/99999",

                headers=auth_headers

            )

            

            assert response.status_code == 404

    

    # PUT /users/{id} Tests

    class TestUpdateUser:

        """PUT /users/{id} endpoint testleri."""

        

        def test_update_user_success(self, auth_headers, created_user):

            """Kullanıcı başarıyla güncellenir."""

            payload = {"name": "Updated Name"}

            

            response = requests.put(

                f"{BASE_URL}/users/{created_user['id']}",

                json=payload,

                headers=auth_headers

            )

            

            assert response.status_code == 200

            data = response.json()

            assert data["name"] == "Updated Name"

    

    # DELETE /users/{id} Tests

    class TestDeleteUser:

        """DELETE /users/{id} endpoint testleri."""

        

        def test_delete_user_success(self, auth_headers):

            """Kullanıcı başarıyla silinir."""

            # Create user to delete

            create_resp = requests.post(

                f"{BASE_URL}/users",

                json={"email": "todelete@example.com", "name": "To Delete", "role": "user"},

                headers=auth_headers

            )

            user_id = create_resp.json()["id"]

            

            # Delete

            response = requests.delete(

                f"{BASE_URL}/users/{user_id}",

                headers=auth_headers

            )

            

            assert response.status_code == 204

            

            # Verify deleted

            get_resp = requests.get(

                f"{BASE_URL}/users/{user_id}",

                headers=auth_headers

            )

            assert get_resp.status_code == 404

Performans Test Şablonları

Load Test (k6)

k6 ile yük testi yazmak için.

Bu API için k6 load test yaz.



API:

Endpoint: [...]

Beklenen RPS: [...]

Kabul edilebilir response time: [...]



SENARYO:

[Yük test senaryosu]



ÖRNEK ÇIKTI YAPISI:



import http from "k6/http";

import { check, sleep } from "k6";

import { Rate, Trend } from "k6/metrics";



// Custom metrics

const errorRate = new Rate("errors");

const responseTime = new Trend("response_time");



// Test configuration

export const options = {

    stages: [

        { duration: "1m", target: 50 },   // Ramp up to 50 users

        { duration: "3m", target: 50 },   // Stay at 50 users

        { duration: "1m", target: 100 },  // Ramp up to 100 users

        { duration: "3m", target: 100 },  // Stay at 100 users

        { duration: "1m", target: 0 },    // Ramp down

    ],

    thresholds: {

        http_req_duration: ["p(95)<500"],  // 95% of requests under 500ms

        http_req_failed: ["rate<0.01"],    // Error rate under 1%

        errors: ["rate<0.01"],

    },

};



const BASE_URL = "http://api.example.com";



// Setup - runs once before test

export function setup() {

    // Login and get token

    const loginRes = http.post(`${BASE_URL}/auth/login`, JSON.stringify({

        email: "loadtest@example.com",

        password: "testpassword"

    }), {

        headers: { "Content-Type": "application/json" }

    });

    

    return { token: loginRes.json("access_token") };

}



// Main test function

export default function(data) {

    const headers = {

        "Authorization": `Bearer ${data.token}`,

        "Content-Type": "application/json"

    };



    // Scenario 1: Get users list

    const getUsersRes = http.get(`${BASE_URL}/users`, { headers });

    

    check(getUsersRes, {

        "GET /users status is 200": (r) => r.status === 200,

        "GET /users response time OK": (r) => r.timings.duration < 500,

    });

    

    errorRate.add(getUsersRes.status !== 200);

    responseTime.add(getUsersRes.timings.duration);

    

    sleep(1);



    // Scenario 2: Get single user

    const userId = Math.floor(Math.random() * 100) + 1;

    const getUserRes = http.get(`${BASE_URL}/users/${userId}`, { headers });

    

    check(getUserRes, {

        "GET /users/{id} status is 200 or 404": (r) => [200, 404].includes(r.status),

    });

    

    sleep(1);



    // Scenario 3: Create user

    const createUserRes = http.post(`${BASE_URL}/users`, JSON.stringify({

        email: `loadtest_${Date.now()}_${Math.random()}@example.com`,

        name: "Load Test User",

        role: "user"

    }), { headers });

    

    check(createUserRes, {

        "POST /users status is 201": (r) => r.status === 201,

    });

    

    // Cleanup - delete created user

    if (createUserRes.status === 201) {

        const newUserId = createUserRes.json("id");

        http.del(`${BASE_URL}/users/${newUserId}`, null, { headers });

    }

    

    sleep(1);

}



// Teardown - runs once after test

export function teardown(data) {

    console.log("Load test completed");

}



// HTML report generation command:

// k6 run --out json=results.json script.js

// Then use k6-reporter to generate HTML

Benchmark Test

Kod performansını ölçmek için benchmark testi.

Bu fonksiyon için benchmark test yaz.



FONKSİYON:

[Benchmark yapılacak kodu yapıştır]



BENCHMARK GEREKSİNİMLERİ:

Farklı input boyutları

Karşılaştırmalı implementasyonlar

Memory kullanımı ölçümü



ÖRNEK ÇIKTI YAPISI (Python + pytest-benchmark):



import pytest

from typing import List



# Functions to benchmark

def bubble_sort(arr: List[int]) -> List[int]:

    """Bubble sort implementasyonu."""

    arr = arr.copy()

    n = len(arr)

    for i in range(n):

        for j in range(0, n-i-1):

            if arr[j] > arr[j+1]:

                arr[j], arr[j+1] = arr[j+1], arr[j]

    return arr



def quick_sort(arr: List[int]) -> List[int]:

    """Quick sort implementasyonu."""

    if len(arr) <= 1:

        return arr

    pivot = arr[len(arr) // 2]

    left = [x for x in arr if x < pivot]

    middle = [x for x in arr if x == pivot]

    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)



def builtin_sort(arr: List[int]) -> List[int]:

    """Python builtin sort."""

    return sorted(arr)



# Test data fixtures

@pytest.fixture(params=[100, 1000, 10000])

def random_array(request):

    """Farklı boyutlarda random array."""

    import random

    size = request.param

    return [random.randint(0, 10000) for _ in range(size)]



@pytest.fixture

def small_array():

    return [64, 34, 25, 12, 22, 11, 90]



@pytest.fixture

def sorted_array():

    return list(range(1000))



@pytest.fixture

def reverse_sorted_array():

    return list(range(1000, 0, -1))



# Benchmark tests

class TestSortingBenchmarks:

    """Sorting algoritmaları benchmark testleri."""



    def test_bubble_sort_benchmark(self, benchmark, random_array):

        """Bubble sort performansı."""

        result = benchmark(bubble_sort, random_array)

        assert result == sorted(random_array)



    def test_quick_sort_benchmark(self, benchmark, random_array):

        """Quick sort performansı."""

        result = benchmark(quick_sort, random_array)

        assert result == sorted(random_array)



    def test_builtin_sort_benchmark(self, benchmark, random_array):

        """Builtin sort performansı."""

        result = benchmark(builtin_sort, random_array)

        assert result == sorted(random_array)



    # Worst case scenarios

    def test_bubble_sort_worst_case(self, benchmark, reverse_sorted_array):

        """Bubble sort worst case (reverse sorted)."""

        benchmark(bubble_sort, reverse_sorted_array)



    def test_quick_sort_worst_case(self, benchmark, sorted_array):

        """Quick sort worst case (already sorted)."""

        benchmark(quick_sort, sorted_array)



# Memory benchmark

def test_memory_usage():

    """Memory kullanımı testi."""

    import tracemalloc

    

    tracemalloc.start()

    

    # Run function

    data = [i for i in range(100000)]

    result = quick_sort(data)

    

    current, peak = tracemalloc.get_traced_memory()

    tracemalloc.stop()

    

    print(f"Current memory: {current / 1024 / 1024:.2f} MB")

    print(f"Peak memory: {peak / 1024 / 1024:.2f} MB")

    

    assert peak / 1024 / 1024 < 100  # Under 100MB

Test Driven Development (TDD) Şablonları

TDD Cycle

TDD yaklaşımıyla geliştirme için.

TDD yaklaşımıyla şu özelliği geliştirmeme yardım et.



ÖZELLİK:

[Geliştirilecek özelliği açıkla]



KABUL KRİTERLERİ:

[Özelliğin kabul kriterlerini listele]



TDD CYCLE:



ADIM 1 - RED (Failing Test Yaz):



İlk olarak geçmeyen test yaz.

Test, istenen davranışı tanımlamalı.

Test çalıştırıldığında FAIL etmeli.



def test_feature_does_expected_behavior():

    # Arrange

    [Setup]

    

    # Act

    result = feature_function(input)

    

    # Assert

    assert result == expected_output



# Bu test şu an FAIL eder çünkü feature_function henüz yok.



ADIM 2 - GREEN (Minimum Kod Yaz):



Testi geçirecek minimum kodu yaz.

Güzel veya optimize olmak zorunda değil.

Sadece testi geçirmeli.



def feature_function(input):

    # Minimum implementation

    return expected_output



# Test şimdi PASS eder.



ADIM 3 - REFACTOR:



Kodu iyileştir.

Testler hala geçmeli.

DRY, clean code prensipleri uygula.



def feature_function(input):

    # Refactored, clean implementation

    validated = validate(input)

    processed = process(validated)

    return format_output(processed)



# Testler hala PASS eder.



DÖNGÜYÜ TEKRARLA:



Sonraki test case için aynı döngüyü uygula.

Her seferinde küçük adımlarla ilerle.

Her adımda testlerin geçtiğinden emin ol.

BDD Gherkin Senaryoları

Behavior Driven Development için Gherkin senaryoları.

Bu özellik için BDD Gherkin senaryoları yaz.



ÖZELLİK:

[Özellik açıklaması]



KULLANICI HİKAYESİ:

As a [kullanıcı tipi]

I want to [eylem]

So that [fayda]



ÖRNEK ÇIKTI YAPISI:



Feature: User Registration

  As a new visitor

  I want to create an account

  So that I can access member features



  Background:

    Given I am on the registration page

    And the registration form is displayed



  Scenario: Successful registration with valid data

    Given I enter "John Doe" in the name field

    And I enter "john@example.com" in the email field

    And I enter "SecurePass123!" in the password field

    And I enter "SecurePass123!" in the confirm password field

    And I check the terms and conditions checkbox

    When I click the register button

    Then I should be redirected to the dashboard

    And I should see a welcome message "Welcome, John"

    And I should receive a confirmation email



  Scenario: Registration fails with existing email

    Given a user with email "existing@example.com" already exists

    And I enter "Jane Doe" in the name field

    And I enter "existing@example.com" in the email field

    And I enter "SecurePass123!" in the password field

    And I enter "SecurePass123!" in the confirm password field

    And I check the terms and conditions checkbox

    When I click the register button

    Then I should see an error message "Email already exists"

    And I should remain on the registration page



  Scenario Outline: Registration fails with invalid data

    Given I enter "<name>" in the name field

    And I enter "<email>" in the email field

    And I enter "<password>" in the password field

    And I enter "<confirm>" in the confirm password field

    When I click the register button

    Then I should see an error message "<error>"



    Examples:

      | name     | email           | password      | confirm       | error                      |

      |          | john@test.com   | Pass123!      | Pass123!      | Name is required           |

      | John     | invalid-email   | Pass123!      | Pass123!      | Invalid email format       |

      | John     | john@test.com   | weak          | weak          | Password too weak          |

      | John     | john@test.com   | Pass123!      | Different!    | Passwords do not match     |



  Scenario: Password strength validation

    Given I enter "John Doe" in the name field

    And I enter "john@example.com" in the email field

    When I enter "abc" in the password field

    Then I should see password strength indicator as "weak"

    When I enter "Abc123!@" in the password field

    Then I should see password strength indicator as "strong"

Mock ve Stub Şablonları

Mock Stratejileri

Farklı mock senaryoları için şablonlar.

Bu kod için mock stratejisi öner ve uygula.



KOD:

[Mock gerektiren kodu yapıştır]



BAĞIMLILIKLAR:

[External dependencies listesi]



MOCK STRATEJİLERİ:



1. FUNCTION MOCK:



from unittest.mock import Mock, patch



# Simple function mock

@patch("module.external_function")

def test_with_mocked_function(mock_func):

    mock_func.return_value = "mocked_result"

    

    result = function_under_test()

    

    assert result == "expected"

    mock_func.assert_called_once()



2. CLASS MOCK:



# Mock entire class

@patch("module.ExternalService")

def test_with_mocked_class(MockService):

    mock_instance = MockService.return_value

    mock_instance.get_data.return_value = {"key": "value"}

    

    result = function_using_service()

    

    assert result["key"] == "value"



3. ASYNC MOCK:



from unittest.mock import AsyncMock



@patch("module.async_function", new_callable=AsyncMock)

async def test_async_mock(mock_async):

    mock_async.return_value = "async_result"

    

    result = await function_with_async_call()

    

    assert result == "expected"



4. CONTEXT MANAGER MOCK:



@patch("builtins.open", mock_open(read_data="file content"))

def test_file_reading(mock_file):

    result = read_config_file()

    

    assert "file content" in result



5. PARTIAL MOCK (Spy):



from unittest.mock import patch



def test_partial_mock():

    with patch.object(MyClass, "method_to_mock", wraps=MyClass().method_to_mock) as spy:

        instance = MyClass()

        instance.method_to_mock()

        

        spy.assert_called_once()



6. MOCK SIDE EFFECTS:



# Return different values on successive calls

mock_func.side_effect = ["first", "second", "third"]



# Raise exception

mock_func.side_effect = ValueError("error message")



# Custom side effect function

def custom_side_effect(arg):

    if arg == "special":

        return "special_result"

    return "default"



mock_func.side_effect = custom_side_effect



7. ASSERTION HELPERS:



# Verify calls

mock_func.assert_called()

mock_func.assert_called_once()

mock_func.assert_called_with("expected_arg")

mock_func.assert_called_once_with("expected_arg", key="value")



# Verify call count

assert mock_func.call_count == 3



# Verify call arguments

mock_func.assert_any_call("arg1")

calls = [call("arg1"), call("arg2")]

mock_func.assert_has_calls(calls, any_order=True)



# Reset mock

mock_func.reset_mock()

Test Coverage ve Kalite

Coverage Analizi

Test coverage analizi ve iyileştirme.

Bu kod için test coverage analizi yap ve eksik testleri öner.



KOD:

[Kodu yapıştır]



MEVCUT TESTLER:

[Varsa mevcut testleri yapıştır]



COVERAGE ANALİZİ:



1. LINE COVERAGE:

Toplam satır: [X]

Test edilen: [Y]

Coverage: [%Z]



Test edilmeyen satırlar:

Satır [A]: [Açıklama]

Satır [B]: [Açıklama]



2. BRANCH COVERAGE:

Toplam branch: [X]

Test edilen: [Y]

Coverage: [%Z]



Test edilmeyen branch lar:

if bloğu satır [X]: else branch test edilmemiş

switch case satır [Y]: default case test edilmemiş



3. FUNCTION COVERAGE:

Toplam fonksiyon: [X]

Test edilen: [Y]

Coverage: [%Z]



Test edilmeyen fonksiyonlar:

[function_name]: [Neden test edilmeli]



4. EKSİK TEST ÖNERİLERİ:



Öncelik 1 - Kritik:

def test_[eksik_senaryo]():

    [Test kodu]



Öncelik 2 - Önemli:

def test_[eksik_senaryo]():

    [Test kodu]



5. COVERAGE ARTIRMA PLANI:



Mevcut: %[X]

Hedef: %[Y]



Adım 1: [X] testleri ekle - +%[Z] coverage

Adım 2: [Y] testleri ekle - +%[W] coverage

Test Yazımı İpuçları

Genel İlkeler:

Her test tek bir şeyi test etsin
Test isimleri açıklayıcı olsun
Arrange-Act-Assert pattern kullanın
Test isolation sağlayın
Flaky test lerden kaçının

Unit Test İçin:

External dependency leri mockla
Edge case leri unutma
Error case leri test et
Boundary değerleri kontrol et
Hızlı çalışmalı

Integration Test İçin:

Test database kullan
Her test sonrası temizlik yap
Transaction rollback kullan
Real service ler yerine test double kullan

E2E Test İçin:

Stabil selector lar kullan (data-testid)
Wait mekanizmalarını doğru kullan
Test data yönetimini planla
Screenshot ve video kaydet

AI ile Test Yazarken:

AI ürettiği testleri çalıştır ve doğrula
Assertion mantığını kontrol et
Mock ların doğru yapılandırıldığından emin ol
Edge case lerin kapsandığını doğrula
Test coverage raporunu incele

Bu rehber işine yaradı mı?

Öğrenme yolu · İleri Adım 8 / 10 İlerlemeni kaydetmek için giriş yap Sıradaki adım

Puan ver

Henüz puan yok

Paylaş

Bu içerikte bir hata mı gördün?

Yorumlar

Bu içerik hakkında üyeler neler düşünüyor?

Yorum yazmak için ücretsiz üye ol veya giriş yap. 5.997 üye aramızda.

Google Giriş Kayıt Ol

Bildirimler