Yardımcı Sınıflar
*****************


HttpAssert .{data-version:2.5.6}
--------------------------------
`Tester\HttpAssert` sınıfı, HTTP sunucularını test etmek için araçlar sunar. Akıcı bir arayüzle HTTP istekleri yapmanızı ve durum kodlarını, header'ları ve yanıt gövdesinin içeriğini kolayca doğrulamanızı sağlar.

```php
# Temel HTTP isteği ve yanıt doğrulaması
$response = Tester\HttpAssert::fetch('https://example.com/api/users');
$response
	->expectCode(200)
	->expectHeader('Content-Type', contains: 'json')
	->expectBody(contains: 'users');
```

`fetch()` metodu varsayılan olarak bir GET isteği oluşturur, ama tüm parametreler özelleştirilebilir:

```php
HttpAssert::fetch(
	'https://api.example.com/users',
	method: 'POST',
	headers: [
		'Authorization' => 'Bearer token123',  # ilişkisel dizi
		'Accept: application/json',            # ya da dize biçimi
	],
	cookies: ['session' => 'abc123'],
	follow: false,                             # yönlendirmeleri izleme
	body: '{"name": "John"}'
)
	->expectCode(201);
```

Durum kodları `expectCode()` ve `denyCode()` metotlarıyla doğrulanabilir. Belirli bir sayı ya da bir doğrulama fonksiyonu verebilirsiniz:

```php
$response
	->expectCode(200)                           # tam kod
	->expectCode(fn($code) => $code < 400)      # özel doğrulama
	->denyCode(404)                             # 404 olmamalı
	->denyCode(fn($code) => $code >= 500);      # sunucu hatası olmamalı
```

Header doğrulaması için `expectHeader()` ve `denyHeader()` metotlarını kullanın. Bir header'ın var olup olmadığını denetleyebilir, tam değerini doğrulayabilir ya da içeriğinin bir parçasını eşleştirebilirsiniz:

```php
$response
	->expectHeader('Content-Type')                     # header var olmalı
	->expectHeader('Content-Type', 'application/json') # tam değer
	->expectHeader('Content-Type', contains: 'json')   # metin içerir
	->expectHeader('Server', matches: 'nginx %a%')     # desene uyar
	->denyHeader('X-Powered-By')                       # header olmamalı
	->denyHeader('X-Debug', contains: 'sensitive')     # metin içermemeli
	->denyHeader('X-Debug', matches: '~debug~i');      # desene uymamalı
```

Yanıt gövdesi doğrulaması `expectBody()` ve `denyBody()` metotlarıyla benzer şekilde çalışır:

```php
$response
	->expectBody('OK')                              # tam değer
	->expectBody(contains: '"status": "success"')   # JSON parçası içerir
	->expectBody(matches: '%A% hello %A%')          # desene uyar
	->expectBody(fn($body) => json_decode($body) !== null) # özel doğrulama
	->denyBody('Error occurred')                    # tam değere sahip olmamalı
	->denyBody(contains: 'error')                   # metin içermemeli
	->denyBody(matches: '~exception|fatal~i');      # desene uymamalı
```

`follow` parametresi, HttpAssert'in HTTP yönlendirmelerini nasıl ele alacağını denetler:

```php
# Yönlendirmeyi izlemeden test etme (varsayılan)
HttpAssert::fetch('https://example.com/redirect', follow: false)
	->expectCode(301)
	->expectHeader('Location', 'https://example.com/new-url');

# Tüm yönlendirmeleri son yanıta dek izleme
HttpAssert::fetch('https://example.com/redirect', follow: true)
	->expectCode(200)
	->expectBody(contains: 'final content');
```


DomQuery
--------
`Tester\DomQuery`, `SimpleXMLElement` sınıfını genişleten ve HTML ya da XML içinde CSS seçicileriyle kolay sorgulama sunan bir sınıftır.

```php
# HTML dizesinden DomQuery oluştur
$dom = Tester\DomQuery::fromHtml('
	<article class="post">
		<h1>Title</h1>
		<div class="content">Text</div>
	</article>
');

# CSS seçicileriyle eleman varlığını test et
Assert::true($dom->has('article.post'));
Assert::true($dom->has('h1'));

# elemanları DomQuery nesnelerinden oluşan bir dizi olarak bul
$headings = $dom->find('h1');
Assert::same('Title', (string) $headings[0]);

# elemanın seçiciye uyup uymadığını test et (2.5.3 sürümünden beri)
$content = $dom->find('.content')[0];
Assert::true($content->matches('div'));
Assert::false($content->matches('p'));

# seçiciye uyan en yakın atayı bul (2.5.5 sürümünden beri)
$article = $content->closest('.post');
Assert::true($article->matches('article'));
```

XML belgeleri için `fromXml()` metodunu kullanın:

```php
$dom = Tester\DomQuery::fromXml('<catalog><item>First</item></catalog>');
Assert::true($dom->has('item'));
```


FileMock
--------
`Tester\FileMock`, dosyaları bellekte taklit eder ve `fopen()`, `file_get_contents()`, `parse_ini_file()` gibi fonksiyonları kullanan kodu test etmeyi kolaylaştırır. Örnek kullanım:

```php
# Test edilen sınıf
class Logger
{
	public function __construct(
		private string $logFile,
	) {
	}

	public function log(string $message): void
	{
		file_put_contents($this->logFile, $message . "\n", FILE_APPEND);
	}
}

# Yeni boş dosya
$file = Tester\FileMock::create('');

$logger = new Logger($file);
$logger->log('Login');
$logger->log('Logout');

# Oluşturulan içeriği test et
Assert::same("Login\nLogout\n", file_get_contents($file));
```

İsteğe bağlı ikinci parametre `$extension`, üretilen URL'deki dosya uzantısını ayarlar; test edilen kod buna göre karar veriyorsa kullanışlıdır:

```php
$file = Tester\FileMock::create('{"key": "value"}', 'json');
```


Assert::with() .[filter]
------------------------
Bu bir assertion değil, nesnelerin private metotlarını ve özelliklerini test etmeye yarayan bir yardımcıdır.

```php
class Entity
{
	private $enabled;
	// ...
}

$ent = new Entity;

Assert::with($ent, function () {
	Assert::true($this->enabled); // private $ent->enabled erişilebilir
});
```


Helpers::purge() .[filter]
--------------------------
`purge()` metodu belirtilen dizini oluşturur, zaten varsa içeriğinin tamamını siler. Geçici bir dizin oluşturmak için yararlıdır. Örneğin `tests/bootstrap.php` içinde:

```php
@mkdir(__DIR__ . '/tmp');  # @ - dizin zaten var olabilir

define('TempDir', __DIR__ . '/tmp/' . getmypid());
Tester\Helpers::purge(TempDir);
```


Environment::lock() .[filter]
-----------------------------
Testler paralel çalışır. Ancak bazen testlerin çalışmasının örtüşmemesi gerekir. Tipik olarak veritabanı testleri, veritabanı içeriğinin hazırlanmasını ve çalışması sırasında başka hiçbir testin veritabanına karışmamasını gerektirir. Bu testlerde `Tester\Environment::lock($name, $dir)` kullanırız:

```php
Tester\Environment::lock('database', __DIR__ . '/tmp');
```

İlk parametre kilidin adı, ikincisi kilidin saklanacağı dizinin yoludur. Kilidi ilk alan test devam eder, diğer testler onun tamamlanmasını beklemek zorundadır.


Environment::bypassFinals() .[filter]
-------------------------------------
`final` işaretli sınıfları ya da metotları test etmek zordur. Bir testin başında `Tester\Environment::bypassFinals()` çağırmak, kod yüklenirken `final` anahtar sözcüklerinin atlanmasını sağlar.

```php
require __DIR__ . '/bootstrap.php';

Tester\Environment::bypassFinals();

class MyClass extends NormallyFinalClass  # <-- NormallyFinalClass artık final değil
{
	// ...
}
```


Environment::setup() .[filter]
------------------------------
- hata dökümlerinin okunurluğunu artırır (renklendirme dahil); aksi hâlde PHP'nin varsayılan çağrı yığını yazdırılır
- testte assertion çağrıldığının denetlenmesini sağlar; aksi hâlde assertion'sız testler (örneğin unutulanlar) de geçer
- çalıştırılan kod hakkında bilgi toplamayı otomatik başlatır (`--coverage` kullanıldığında) (ayrıntısı aşağıda)
- betiğin sonunda OK ya da FAILURE durumunu yazdırır


Environment::setupFunctions() .[filter]{data-version:2.5.0}
-----------------------------------------------------------
Testlerinizi yapılandırabileceğiniz genel `test()`, `testException()`, `testNoError()`, `setUp()` ve `tearDown()` fonksiyonlarını oluşturur.

```php
test('test açıklaması', function () {
	Assert::same(123, foo());
	Assert::false(bar());
	// ...
});
```


Environment::VariableRunner .[filter]
-------------------------------------
Testin doğrudan mı yoksa Tester üzerinden mi çalıştırıldığını belirlemenizi sağlar.

```php
if (getenv(Tester\Environment::VariableRunner)) {
	# Tester tarafından çalıştırıldı
} else {
	# başka bir yolla çalıştırıldı
}
```


Environment::VariableThread .[filter]
-------------------------------------
Tester, testleri belirtilen sayıda iş parçacığında paralel çalıştırır. İş parçacığı numarasıyla ilgileniyorsak, onu ortam değişkeninden buluruz:

```php
echo "Running in thread number " . getenv(Tester\Environment::VariableThread);
```