// ① Playwright'ın test runner'ını ve assertion kütüphanesini import et
import { test, expect } from '@playwright/test';

// ② test.describe → birden fazla testi mantıksal olarak gruplar
//    İlk argüman: grup adı (raporlarda görünür)
test.describe('Playwright Ana Sayfa', () => {

  // ③ test() → tek bir test case tanımlar
  //    İlk argüman: test adı + etiketler (tag sistemi için)
  //    İkinci argüman: async callback, { page } ile tarayıcı sayfasını alır
  test('sayfa başlığı doğru yükleniyor @smoke @critical', async ({ page }) => {

    // ④ page.goto() → belirtilen URL'e gider
    //    baseURL playwright.config.ts'de tanımlı olduğunda otomatik eklenir
    await page.goto('https://playwright.dev');

    // ⑤ expect() → bir değeri veya locator'ı test eder
    //    toHaveTitle() → sayfanın <title> tag'ini kontrol eder
    //    /regex/ veya string kabul eder
    await expect(page).toHaveTitle(/Playwright/);
  });

  test('ana navigasyon görünür @smoke @ui', async ({ page }) => {
    await page.goto('https://playwright.dev');

    // ⑥ page.locator() → CSS/XPath ile element seçer
    // ⑦ toBeVisible() → elementin DOM'da görünür olduğunu kontrol eder
    await expect(page.locator('nav')).toBeVisible();
  });

  test('docs linkine tıklanabiliyor @regression @ui', async ({ page }) => {
    await page.goto('https://playwright.dev');

    // ⑧ getByRole() → ARIA rolüne göre element bulur (erişilebilirlik ağacı)
    //    'link' rolü → <a> tag'leri, name: linkın içindeki metin
    await page.getByRole('link', { name: 'Docs' }).click();

    // ⑨ toHaveURL() → mevcut URL'in beklenen değerle eşleşip eşleşmediğini kontrol eder
    await expect(page).toHaveURL(/docs/);
  });
});

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({

  // testDir: Test dosyalarının aranacağı kök dizin
  testDir: './tests/web',

  // outputDir: Screenshot, video, trace gibi test artifact'larının kaydedileceği yer
  outputDir: './reports/playwright-results',

  // reporter: Hangi raporlayıcıların kullanılacağı (birden fazla olabilir)
  reporter: [
    ['list'],                                              // Terminal'de satır satır sonuç
    ['html', { outputFolder: './reports/playwright', open: 'never' }], // HTML rapor
  ],

  use: {
    // baseURL: page.goto('/path') çağrılarında otomatik ön ek olarak eklenir
    baseURL: 'https://jsonplaceholder.typicode.com',

    // trace: İlk başarısız denemede trace kaydeder (hata ayıklamak için)
    // 'on' | 'off' | 'on-first-retry' | 'retain-on-failure'
    trace: 'on-first-retry',

    // screenshot: Sadece başarısız testlerde ekran görüntüsü alır
    // 'on' | 'off' | 'only-on-failure'
    screenshot: 'only-on-failure',
  },

  // projects: Farklı tarayıcı/cihaz kombinasyonlarını tanımlar
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },  // Hazır cihaz profili kullanır
    },
    // İlave projeler kolayca eklenir:
    // { name: 'firefox',      use: { ...devices['Desktop Firefox'] } },
    // { name: 'mobile-safari', use: { ...devices['iPhone 13'] } },
  ],
});

import { test, expect } from '@playwright/test';

test.describe('Form ve Input Testleri', () => {

  test('arama formu çalışıyor @smoke @ui', async ({ page }) => {
    await page.goto('https://playwright.dev');

    // Butona tıkla — arama modalını aç
    await page.getByRole('button', { name: 'Search' }).click();

    // Açılan input'a metin yaz
    await page.keyboard.type('page');

    // İçinde 'page' geçen sonuçların göründüğünü doğrula
    await expect(page.getByRole('option').first()).toBeVisible();
  });

  test('viewport ve responsive kontrol @regression @ui', async ({ page }) => {
    // Tarayıcı penceresini 375×812 piksel (iPhone boyutu) yap
    await page.setViewportSize({ width: 375, height: 812 });
    await page.goto('https://playwright.dev');

    // Masaüstü navigasyonun mobilde gizlendiğini doğrula
    await expect(page.locator('.navbar__items--right')).toBeHidden();
  });
});

import { Page } from '@playwright/test';

// Tüm POM sınıflarının miras aldığı temel sınıf
export class BasePage {
  protected readonly page: Page;

  // Constructor: Playwright'ın page nesnesini alır ve saklar
  constructor(page: Page) {
    this.page = page;
  }

  // Ortak metodlar — tüm alt sınıflar kullanabilir
  async navigate(path: string): Promise<void> {
    await this.page.goto(path);
  }

  async getTitle(): Promise<string> {
    return await this.page.title();
  }

  async waitForNetworkIdle(): Promise<void> {
    // 500ms boyunca yeni network isteği başlamamasını bekler
    await this.page.waitForLoadState('networkidle');
  }

  async getURL(): Promise<string> {
    return this.page.url();
  }
}

import { Page, Locator } from '@playwright/test';
import { BasePage } from './BasePage';

export class PlaywrightHomePage extends BasePage {

  // readonly Locator'lar: sınıf oluşturulduğunda tanımlanır, değişmez
  // Bu elementler test boyunca tekrar tekrar kullanılabilir
  readonly navbar: Locator;
  readonly docsLink: Locator;
  readonly searchButton: Locator;

  constructor(page: Page) {
    super(page); // BasePage'i başlatır

    // Locator'ları burada tanımla — lazy evaluation: henüz DOM'a bakmaz
    this.navbar = page.locator('nav.navbar');
    this.docsLink = page.getByRole('link', { name: 'Docs' });
    this.searchButton = page.getByRole('button', { name: 'Search' });
  }

  // Sayfaya özel metodlar — testte tek satırla karmaşık işlem yapılır
  async goto() {
    await this.navigate('https://playwright.dev');
  }

  async clickDocs() {
    await this.docsLink.click();
  }

  async searchFor(term: string) {
    await this.searchButton.click();
    await this.page.keyboard.type(term);
  }

  async isNavbarVisible(): Promise<boolean> {
    return await this.navbar.isVisible();
  }
}

import { test, expect } from '@playwright/test';
import { PlaywrightHomePage } from './pages/PlaywrightHomePage';

test.describe('POM ile Ana Sayfa Testleri', () => {

  test('sayfa başlığı doğru @smoke @critical', async ({ page }) => {
    // POM nesnesini oluştur — page fixture'ı geçir
    const homePage = new PlaywrightHomePage(page);

    // Metodu çağır — goto() içinde navigate() BasePage'den miras alır
    await homePage.goto();

    // POM metodunu kullanarak assertion yap
    await expect(page).toHaveTitle(/Playwright/);
  });

  test('docs sayfasına yönlendiriyor @regression @ui', async ({ page }) => {
    const homePage = new PlaywrightHomePage(page);
    await homePage.goto();

    // clickDocs() → locator tanımı ve click() mantığını kapsüller
    await homePage.clickDocs();

    await expect(page).toHaveURL(/docs/);
  });
});

import { test, expect } from '@playwright/test';

test('network isteği yakalanıyor @regression @network', async ({ page }) => {
  let intercepted = false;

  // page.on('request') → sayfadan çıkan HER isteği dinler
  // Event listener olduğu için await gerekmez
  page.on('request', (req) => {
    if (req.url().includes('jsonplaceholder')) {
      intercepted = true;
    }
  });

  // baseURL'den /posts/1'e git → XHR/fetch isteği tetikler
  await page.goto('/posts/1');

  expect(intercepted).toBe(true);
});

test('API yanıtı mock ediliyor @smoke @network', async ({ page }) => {

  // page.route() → belirli URL pattern'lerine gelen istekleri yakalar ve değiştirir
  // '**' globbing desteği var: '**/posts/1' → herhangi bir origin + /posts/1
  await page.route('**/posts/1', async (route) => {

    // route.fulfill() → isteği gerçeğe göndermeden sahte yanıt döner
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({
        id: 1,
        title: 'Mock Post Başlığı',
        body: 'Mock içerik',
        userId: 1
      })
    });
  });

  await page.goto('/posts/1');

  // Sayfadaki içeriğin mock datayı yansıttığını doğrula
  const body = await page.evaluate(() => document.body.innerText);
  expect(body).toContain('Mock Post Başlığı');
});

import { test, expect } from '@playwright/test';

// { request } → tarayıcı açılmaz, sadece HTTP context başlar
test.describe('Playwright API Testleri — request fixture', () => {

  // ── GET — Tek kayıt ─────────────────────────────────────────
  test('GET /posts/1 — post detayı geliyor @smoke @network', async ({ request }) => {

    // request.get() → GET isteği gönderir, APIResponse döner
    const response = await request.get(
      'https://jsonplaceholder.typicode.com/posts/1'
    );

    // toBeOK() → status code 200-299 aralığında mı kontrol eder
    await expect(response).toBeOK();

    // response.status() → HTTP status code'u döner
    expect(response.status()).toBe(200);

    // response.json() → body'yi parse ederek JS objesine çevirir
    const body = await response.json();
    expect(body.id).toBe(1);
    expect(body.userId).toBeDefined();
    expect(typeof body.title).toBe('string');
  });

  // ── GET — Liste + uzunluk kontrolü ──────────────────────────
  test('GET /posts — 100 post dönüyor @regression @network', async ({ request }) => {
    const response = await request.get(
      'https://jsonplaceholder.typicode.com/posts'
    );
    await expect(response).toBeOK();

    const posts = await response.json();
    expect(Array.isArray(posts)).toBe(true);
    expect(posts).toHaveLength(100);

    // Her elemanın beklenen alanları olduğunu kontrol et
    expect(posts[0]).toMatchObject({
      id: expect.any(Number),
      title: expect.any(String),
      body: expect.any(String),
      userId: expect.any(Number),
    });
  });

  // ── POST — Yeni kayıt oluştur ────────────────────────────────
  test('POST /posts — yeni post oluşturuluyor @smoke @network', async ({ request }) => {
    const response = await request.post(
      'https://jsonplaceholder.typicode.com/posts',
      {
        // data: obje verince otomatik JSON.stringify + Content-Type: application/json
        data: {
          title: 'Playwright API Test',
          body: 'request fixture ile yazılmış test',
          userId: 1,
        },
      }
    );

    // Başarılı oluşturma → 201 Created
    expect(response.status()).toBe(201);

    const created = await response.json();
    expect(created.id).toBeDefined();     // API yeni ID atamış mı?
    expect(created.title).toBe('Playwright API Test');
    expect(created.userId).toBe(1);
  });

  // ── PUT — Kaydı güncelle ─────────────────────────────────────
  test('PUT /posts/1 — post güncelleniyor @regression @network', async ({ request }) => {
    const response = await request.put(
      'https://jsonplaceholder.typicode.com/posts/1',
      {
        data: {
          id: 1,
          title: 'Güncellenmiş Başlık',
          body: 'Güncellenmiş içerik',
          userId: 1,
        },
      }
    );
    await expect(response).toBeOK();

    const updated = await response.json();
    expect(updated.title).toBe('Güncellenmiş Başlık');
  });

  // ── PATCH — Kısmi güncelleme ─────────────────────────────────
  test('PATCH /posts/1 — sadece başlık değişiyor @regression @network', async ({ request }) => {
    // patch() → tüm kaydı değil, sadece gönderilen alanları günceller
    const response = await request.patch(
      'https://jsonplaceholder.typicode.com/posts/1',
      { data: { title: 'Sadece Başlık Değişti' } }
    );
    await expect(response).toBeOK();

    const patched = await response.json();
    expect(patched.title).toBe('Sadece Başlık Değişti');
    // Diğer alanlar hâlâ mevcut olmalı
    expect(patched.userId).toBeDefined();
  });

  // ── DELETE — Kaydı sil ───────────────────────────────────────
  test('DELETE /posts/1 — post siliniyor @regression @network', async ({ request }) => {
    // delete() → reserved keyword olduğu için Playwright'ta fetch() ile sarılır
    const response = await request.delete(
      'https://jsonplaceholder.typicode.com/posts/1'
    );
    // Silme başarılı → 200 veya 204 döner
    expect([200, 204]).toContain(response.status());
  });

  // ── 404 Error — Var olmayan kaynak ───────────────────────────
  test('GET /posts/9999 — 404 dönüyor @regression @network', async ({ request }) => {
    const response = await request.get(
      'https://jsonplaceholder.typicode.com/posts/9999'
    );
    expect(response.status()).toBe(404);
  });
});

test('Authorization header ile istek @smoke @network', async ({ request }) => {
  const response = await request.get(
    'https://jsonplaceholder.typicode.com/posts/1',
    {
      // headers: isteğe özel HTTP header'ları ekler
      headers: {
        'Authorization': 'Bearer my-token-123',
        'Accept': 'application/json',
        'X-Custom-Header': 'test-value',
      },
    }
  );
  await expect(response).toBeOK();
});

test('Query parametreli istek @smoke @network', async ({ request }) => {
  const response = await request.get(
    'https://jsonplaceholder.typicode.com/posts',
    {
      // params: objeyi otomatik URL query string'e dönüştürür
      // → /posts?userId=1&_limit=5 olur
      params: {
        userId: 1,
        _limit: 5,
      },
    }
  );
  const posts = await response.json();
  expect(posts).toHaveLength(5);
  // Tüm sonuçlar userId=1'e ait mi?
  posts.forEach((p: any) => expect(p.userId).toBe(1));
});

test('Response header kontrolü @regression @network', async ({ request }) => {
  const response = await request.get(
    'https://jsonplaceholder.typicode.com/posts/1'
  );

  // response.headers() → tüm response header'larını obje olarak döner
  const headers = response.headers();
  expect(headers['content-type']).toContain('application/json');

  // response.headersArray() → [{ name, value }] formatında döner
  const headersArr = response.headersArray();
  const ct = headersArr.find((h) => h.name === 'content-type');
  expect(ct?.value).toContain('application/json');
});

import { Page } from '@playwright/test';
import { BasePage } from './BasePage';

export class JsonPlaceholderPage extends BasePage {
  readonly url = 'https://jsonplaceholder.typicode.com';

  async fetchPost(id: number) {
    // this.page.request.get() → page'in request context'ini kullanır
    // Fark: page cookie'lerini, session'ı paylaşır — login sonrası testler için ideal
    const response = await this.page.request.get(`${this.url}/posts/${id}`);
    return response.json(); // Doğrudan objeyi döner
  }

  async fetchUser(id: number) {
    const response = await this.page.request.get(`${this.url}/users/${id}`);
    return response.json();
  }

  async createPost(payload: { title: string; body: string; userId: number }) {
    const response = await this.page.request.post(`${this.url}/posts`, {
      data: payload, // data: {} → Content-Type: application/json otomatik eklenir
    });
    // Hem status hem de body'yi döndür — test katmanında ikisini de kontrol et
    return { status: response.status(), body: await response.json() };
  }
}

import { test, expect } from '@playwright/test';
import { JsonPlaceholderPage } from './pages/JsonPlaceholderPage';

test.describe('POM — JsonPlaceholder API & Mock', () => {
  let apiPage: JsonPlaceholderPage;

  // beforeEach: Her testten önce POM nesnesini taze oluştur
  test.beforeEach(async ({ page }) => {
    apiPage = new JsonPlaceholderPage(page);
  });

  test('post verisi doğru geliyor @smoke @network', async () => {
    const post = await apiPage.fetchPost(1);

    expect(post.id).toBe(1);
    expect(post.userId).toBeDefined();
    expect(typeof post.title).toBe('string');
  });

  test('yeni post oluşturuluyor @regression @network', async () => {
    const { status, body } = await apiPage.createPost({
      title: 'POM Test Post',
      body: 'POM ile yazılmış test.',
      userId: 1,
    });
    expect(status).toBe(201);
    expect(body.title).toBe('POM Test Post');
    expect(body.userId).toBe(1);
  });

  test('API yanıtı mock ediliyor @smoke @network', async ({ page }) => {
    // POM'daki mockGetPost → page.route() kullanarak yanıtı taklit eder
    await apiPage.mockGetPost(1, { id: 1, title: 'Mock Başlık', userId: 99 });

    // Sayfaya git — route() aktif olduğu için gerçek API'ye gidilmez
    await page.goto('https://jsonplaceholder.typicode.com/posts/1');

    const text = await page.textContent('body');
    const data = JSON.parse(text!);

    expect(data.title).toBe('Mock Başlık');
    expect(data.userId).toBe(99);  // Gerçek API'deki 1 değil, mock'taki 99
  });
});

import { test, expect, request as playwrightRequest } from '@playwright/test';

test.describe('APIRequestContext ile Merkezi Ayarlar', () => {
  let apiContext: any;

  // beforeAll: Tüm testlerden önce tek bir context oluştur
  test.beforeAll(async () => {
    apiContext = await playwrightRequest.newContext({
      // baseURL: Tüm isteklerde otomatik ön ek kullanılır
      baseURL: 'https://jsonplaceholder.typicode.com',

      // extraHTTPHeaders: Her istekte gönderilecek ortak header'lar
      extraHTTPHeaders: {
        'Authorization': 'Bearer token-abc',
        'Accept': 'application/json',
        'X-App-Version': '1.0.0',
      },
    });
  });

  // afterAll: Context'i kapat, kaynakları serbest bırak
  test.afterAll(async () => {
    await apiContext.dispose();
  });

  test('posts endpoint @smoke @network', async () => {
    // baseURL tanımlı → sadece path yeterli: '/posts/1'
    const res = await apiContext.get('/posts/1');
    await expect(res).toBeOK();
    const post = await res.json();
    expect(post.id).toBe(1);
  });

  test('users endpoint @smoke @network', async () => {
    const res = await apiContext.get('/users/1');
    const user = await res.json();
    expect(user.name).toBe('Leanne Graham');
  });
});

test('UI testi — öncesinde API ile veri hazırla @regression @ui', async ({ page, request }) => {

  // ── SETUP: API ile test verisi oluştur ───────────────────────
  // { page } ve { request } aynı anda kullanılabilir
  const createRes = await request.post(
    'https://jsonplaceholder.typicode.com/posts',
    { data: { title: 'UI Test İçin Hazırlanan Post', userId: 1, body: '...' } }
  );
  expect(createRes.status()).toBe(201);
  const { id: newPostId } = await createRes.json();

  // ── TEST: Tarayıcıda oluşturulan kaydı göster ────────────────
  await page.goto(`https://jsonplaceholder.typicode.com/posts/${newPostId}`);

  // Sayfanın beklenen içeriği gösterdiğini doğrula
  const content = await page.textContent('body');
  expect(content).toBeTruthy();

  // ── TEARDOWN: API ile test verisini temizle ──────────────────
  const deleteRes = await request.delete(
    `https://jsonplaceholder.typicode.com/posts/${newPostId}`
  );
  expect([200, 204]).toContain(deleteRes.status());
});

// ── request fixture ───────────────────────────────────────────
// • Playwright test'in kendi HTTP context'i
// • Tarayıcı cookie/session'ından bağımsız — izole API testi
// • Tarayıcı açılmaz → daha hızlı
// • Bağımsız API doğrulaması için tercih edilir
test('request fixture örneği', async ({ request }) => {
  const res = await request.get('https://api.example.com/data');
  await expect(res).toBeOK();
});

// ── page.request ──────────────────────────────────────────────
// • Tarayıcı page nesnesiyle birlikte gelir
// • Tarayıcının cookie'lerini, localStorage'ını paylaşır
// • Login sonrası oturum gerektiren endpoint'ler için ideal
// • UI testi içinde API çağrısı yapmak için kullanılır
test('page.request örneği', async ({ page }) => {
  // Kullanıcı login oldu, artık cookie var
  await page.goto('/login');
  await page.fill('#email', 'user@test.com');
  await page.fill('#password', 'pass');
  await page.click('button[type=submit]');

  // Login cookie'si ile korumalı API endpoint'i test et
  const res = await page.request.get('/api/profile');
  await expect(res).toBeOK(); // Cookie olmadan 401 dönerdi
});

import { test, expect } from '@playwright/test';

// ── GET ─────────────────────────────────────────────────────────
test('GET - Kullanıcıdan Veri Çekme', async ({ request }) => {

  // 1. İsteği gönder → endpoint: /posts/1
  const response = await request.get('https://jsonplaceholder.typicode.com/posts/1');

  // 2. Status kod kontrolü — 200 OK bekleniyor
  expect(response.status()).toBe(200);

  // 3. Yanıt gövdesini JSON'a çevir — Playwright bunu otomatik yapmaz
  const body = await response.json();

  // 4. Alan değerlerini doğrula
  expect(body.id).toBe(1);
  expect(body.userId).toBe(1);
  // toBeTruthy() → değer null, undefined, '', 0, false değilse geçer
  // "Başlık dolu mu?" kontrolü için idealdir
  expect(body.title).toBeTruthy();
});

// ── POST ────────────────────────────────────────────────────────
test('POST - Yeni Kayıt Oluşturma', async ({ request }) => {

  // Gönderilecek veriyi önceden hazırla — okunabilirlik için iyi pratik
  const yeniVeri = {
    title: 'Playwright ile API Testi',
    body: 'Bu post isteği ile oluşturuldu.',
    userId: 101
  };

  const response = await request.post(
    'https://jsonplaceholder.typicode.com/posts',
    { data: yeniVeri }  // data: obje → otomatik JSON.stringify + Content-Type: application/json
  );

  // POST başarılıysa 201 Created döner (200 değil!)
  expect(response.status()).toBe(201);

  const body = await response.json();
  // JSONPlaceholder yeni kayda hep 101 ID atar
  expect(body.id).toBe(101);
  expect(body.title).toBe('Playwright ile API Testi');
});

// ── PUT — Önce Çek, Sonra Güncelle Pattern ──────────────────────
test('PUT - Mevcut Kaydı Güncelleme', async ({ request }) => {

  // Adım 1: Güncellemeden ÖNCE mevcut veriyi çek ve logla
  // Bu pattern, hangi değerlerin değiştiğini doğrulamak için kullanılır
  const response1 = await request.get('https://jsonplaceholder.typicode.com/posts/1');
  expect(response1.status()).toBe(200);
  const mevcutVeri = await response1.json();
  console.log('Güncelleme Öncesi Veri:', mevcutVeri);

  // Adım 2: Tam veriyi (id dahil) PUT body'sine ekle
  // PUT = tüm kaydı değiştir; id'yi de göndermek iyi pratiktir
  const guncelVeri = {
    id: 1,
    title: 'Güncellenmiş Başlık',
    body: 'İçerik tamamen değişti.',
    userId: 1
  };

  // URL'in sonundaki '/1' → hangi kaydın güncelleneceğini belirtir
  const response = await request.put(
    'https://jsonplaceholder.typicode.com/posts/1',
    { data: guncelVeri }
  );

  // PUT başarılıysa 200 döner
  expect(response.status()).toBe(200);

  const body = await response.json();
  expect(body.title).toBe('Güncellenmiş Başlık');
});

// ── DELETE ──────────────────────────────────────────────────────
test('DELETE - Kayıt Silme', async ({ request }) => {

  const response = await request.delete('https://jsonplaceholder.typicode.com/posts/1');

  // JSONPlaceholder silme için 200 döner
  // Gerçek API'lerin çoğu 204 No Content döner (body yok)
  expect(response.status()).toBe(200);

  const body = await response.json();
  // JSONPlaceholder silinen kayıt için boş obje {} döner
  console.log(response.status() === 200 ? 'Kayıt başarıyla silindi.' : 'Silme başarısız.');
});

import { test, expect } from '@playwright/test';

// GraphQL'de tek endpoint — tüm sorgular buraya POST gönderir
const url = 'https://countries.trevorblades.com/';

test.describe('Continents GraphQL Tests', () => {

  // ── Test 1: Kıtaları listele ─────────────────────────────────
  test('should fetch list of continents', async ({ request }) => {

    // GraphQL query: template literal ile yazılır
    // Sadece ihtiyaç duyulan alanlar istenir (code, name) — fazlası gelmez
    const query = `
      query {
        continents {
          code
          name
        }
      }
    `;

    // GraphQL'de her zaman POST kullanılır
    // body: { query: "..." } formatı — GraphQL standardı
    const response = await request.post(url, { data: { query } });

    // GraphQL hataları bile 200 döner! Hata → body.errors alanında gelir
    expect(response.status()).toBe(200);

    const responseBody = await response.json();

    // GraphQL yanıtı her zaman { data: { ... } } yapısındadır
    // arrayContaining: array içinde bu objelerin bulunduğunu kontrol eder
    // objectContaining: objenin en azından bu alanları içerdiğini kontrol eder
    expect(responseBody.data.continents).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ code: 'EU', name: 'Europe' }),
        expect.objectContaining({ code: 'AS', name: 'Asia' }),
      ])
    );
  });

  // ── Test 2: Belirli bir dili sorgula ─────────────────────────
  test('should fetch language details for Spanish', async ({ request }) => {

    // GraphQL argument: language(code: "es") → filtre parametresi
    // REST'teki /language?code=es ya da /language/es karşılığı
    const query = `
      query {
        language(code: "es") {
          name
          native
        }
      }
    `;

    const response = await request.post(url, { data: { query } });
    expect(response.status()).toBe(200);

    const responseBody = await response.json();

    // data.language → query'de language(...) diye çağırdık, aynı isimle gelir
    expect(responseBody.data.language.name).toBe('Spanish');
    expect(responseBody.data.language.native).toBe('Español');
  });
});

import { test, expect } from '@playwright/test';

const url = 'https://countries.trevorblades.com/';

test.describe('GraphQL API Test — Nested Query', () => {

  test('should fetch nested data: Turkey and its continent', async ({ request }) => {

    // ── Nested Query Yapısı ──────────────────────────────────────
    // country(code: "TR") → TR kodu ile Türkiye'yi filtrele
    //   name     → ülke adı
    //   capital  → başkent
    //   continent { → ilişkili obje (JOIN gibi düşün)
    //     name   →   kıta adı
    //   }
    // REST'te bu için 2 ayrı istek gerekirdi:
    //   GET /countries/TR  ve  GET /continents/{id}
    // GraphQL'de tek istekte geliyor!
    const query = `
      query {
        country(code: "TR") {
          name
          capital
          continent {
            name
          }
        }
      }
    `;

    const response = await request.post(url, { data: { query: query } });

    // Status her zaman 200 — GraphQL hatalar için bile 200 döner
    expect(response.status()).toBe(200);

    const responseBody = await response.json();

    // expect.soft() → bu assertion başarısız olsa bile test devam eder
    // Tüm alanları tek seferde kontrol etmek için kullanışlı
    // Normal expect() → ilk hata yapılan assertion'da durur
    expect.soft(responseBody.data.country.name).toBe('Turkey');
    expect.soft(responseBody.data.country.capital).toBe('Ankara');

    // Nested objeye nokta notasyonuyla erişim: country → continent → name
    expect.soft(responseBody.data.country.continent.name).toBe('Asia');
  });
});

test('GraphQL hata durumu kontrolü', async ({ request }) => {
  // Var olmayan bir alan sorguluyoruz — GraphQL hata üretmeli
  const query = `
    query {
      country(code: "TR") {
        varOlmayanAlan
      }
    }
  `;

  const response = await request.post(url, { data: { query } });

  // ⚠️ GraphQL hataları için HTTP status yine 200 döner!
  // REST'teki gibi 400/404 bekleme — hata body içinde gelir
  expect(response.status()).toBe(200);

  const body = await response.json();

  // Hata varsa body.errors array'i dolu gelir
  expect(body.errors).toBeDefined();
  expect(body.errors.length).toBeGreaterThan(0);

  // Başarılı yanıtta ise data dolu, errors tanımsız olmalı
  // expect(body.errors).toBeUndefined(); ← başarılı senaryoda bunu kullan
});