Takip et

Tedarikçi API’sını Mock’larken CI’ı Kurtarmak ve Mock’un Bize Yalan Söylemesi: Acı Bir Ders

Yazılım geliştirme süreçlerinde harici bağımlılıklar, özellikle de üçüncü taraf API’ları, sürekli entegrasyon (CI) ve sürekli teslimat (CD) boru hatlarımız için ciddi bir engel teşkil edebilir.

Tedarikçi API’sını Mock’larken CI’ı Kurtarmak ve Mock’un Bize Yalan Söylemesi: Acı Bir Ders

Yazılım geliştirme süreçlerinde harici bağımlılıklar, özellikle de üçüncü taraf API’ları, sürekli entegrasyon (CI) ve sürekli teslimat (CD) boru hatlarımız için ciddi bir engel teşkil edebilir. Bu tür bağımlılıkları yönetmek, test süreçlerimizi hızlandırmak ve maliyetleri düşürmek amacıyla API mock’lama (sahte API oluşturma) yaygın bir pratik haline gelmiştir. Ancak, bu pratik bazen beklenmedik ve can sıkıcı sonuçlar doğurabilir: Mock’lar bize “yalan söylediğinde” ne olur? Bu makalede, bir tedarikçi API’sını mock’larken CI’ı kurtarma çabalarımızın, mock’un doğruluğunu yitirmesiyle nasıl bir kabusa dönüştüğünü ve bu durumdan çıkarılacak dersleri ele alacağız.

Neden API Mock’lama İhtiyacı Duyarız? Temel Kavramlar Nelerdir?

Modern yazılım mimarileri genellikle mikroservisler ve harici hizmet entegrasyonları üzerine kuruludur. Bir uygulamanın ödeme sistemleri, SMS bildirimleri, harita servisleri veya kimlik doğrulama gibi fonksiyonları için üçüncü taraf API’larına bağımlı olması oldukça yaygındır. Bu bağımlılıklar, geliştirme ve test süreçlerinde çeşitli zorluklar yaratır:

  • Erişim Kısıtlamaları ve Maliyetler: Bazı API’lar test ortamı sağlamayabilir veya her istek için ücret talep edebilir. Geliştirme aşamasında binlerce test isteği göndermek hem maliyetli hem de pratik değildir.
  • Performans ve Hız: Harici API çağrıları genellikle ağ gecikmeleri nedeniyle yavaştır. Her test çalıştığında gerçek API’ları çağırmak, CI/CD boru hattının süresini uzatır ve geliştirici verimliliğini düşürür.
  • Güvenilirlik ve Tutarlılık: Üçüncü taraf API’ları bazen erişilemez olabilir, yanıt süreleri dalgalanabilir veya beklenmedik hatalar dönebilir. Bu durum, testlerin tutarsız sonuçlar vermesine (flaky tests) yol açar ve geliştiricilerin kendi kodlarındaki hatalarla dış bağımlılık sorunlarını ayırt etmesini zorlaştırır.
  • Geliştirme Önceliği: Entegre olunacak harici API henüz geliştirme aşamasında olabilir veya bizim entegrasyonumuzdan daha yavaş ilerleyebilir. Bu durumda, kendi geliştirmemizi engellememek için mock’lar kritik rol oynar.

İşte bu noktada API mock’lama devreye girer. Mock’lama, bir servisin veya bileşenin davranışını taklit eden sahte bir nesne veya hizmet oluşturma işlemidir. Temel olarak, gerçek bağımlılığın yerini alarak, uygulamanızın onunla etkileşimini simüle eder. Bu sayede, uygulamanızı gerçek dış bağımlılığa ihtiyaç duymadan test edebilirsiniz. Mock’lar genellikle belirli senaryolar için önceden tanımlanmış yanıtlar (response) döndürürler. Örneğin, bir ödeme API’sının başarılı bir ödeme yanıtı veya başarısız bir ödeme yanıtı gibi senaryoları mock edilebilir.

Mock, Stub ve Fake terimleri sıklıkla birbirinin yerine kullanılsa da, teknik olarak farklılıklar gösterirler:

  • Stub (Sahte Nesne): Test sırasında belirli bir senaryo için önceden tanımlanmış sabit yanıtlar döner. Genellikle testin durumunu etkilemez, sadece gerekli veriyi sağlar.
  • Mock (Taklit Nesne): Stub’dan daha fazlasıdır. Sadece yanıt döndürmekle kalmaz, aynı zamanda gelen çağrıları da kaydeder ve testin sonunda bu çağrıların doğru parametrelerle yapılıp yapılmadığını doğrulamak için kullanılır. Testin davranışını doğrulamaya odaklanır.
  • Fake (Sahte Uygulama): Gerçek uygulamanın basitleştirilmiş bir versiyonudur. Örneğin, bir veritabanı yerine bellek içi bir veritabanı kullanmak bir fake örneğidir. Daha karmaşık davranışları taklit edebilir.

Bu makalede “mock” terimini, genellikle API davranışını taklit eden ve hem yanıt sağlayan hem de çağrıları doğrulayabilen genel bir sahte hizmet anlamında kullanacağız. Mock’lama sayesinde, geliştiriciler hızlı geri bildirim alabilir, test ortamlarının kararlılığını artırabilir ve dış bağımlılıkların oluşturduğu darboğazları ortadan kaldırabilirler. Ancak bu avantajlar, mock’ların doğruluğuna bağlıdır. Aksi takdirde, “yalan söyleyen” bir mock, CI sürecimizi kurtarmak yerine daha büyük sorunlara yol açabilir.

Mock’un “Yalan Söylemesi” Ne Demektir ve CI’ı Nasıl Etkiler?

Bir mock’un “yalan söylemesi” durumu, temel olarak mock’un simüle ettiği gerçek API’nın davranışını doğru bir şekilde yansıtmaması anlamına gelir. Bu, çeşitli şekillerde ortaya çıkabilir ve genellikle fark edilmesi zor, sinsi hatalara yol açar. Bir mock’un yalan söylemesinin başlıca nedenleri ve bunun CI/CD üzerindeki etkileri şunlardır:

  1. Güncel Olmayan Veriler veya Yapı: En sık karşılaşılan senaryo budur. Gerçek API zamanla değişebilir: yeni alanlar eklenebilir, mevcut alanların veri tipleri değişebilir, bazı alanlar kaldırılabilir, hata kodları güncellenebilir veya yanıt yapıları tamamen farklılaşabilir. Eğer mock’umuz bu değişikliklere ayak uyduramazsa, eski veya yanlış verilerle test yapmaya devam ederiz.
  2. Eksik Senaryolar: Mock’lar genellikle sadece en yaygın veya “mutlu yol” (happy path) senaryolarını kapsar. Kenar durumlar (edge cases), hata durumları (örneğin, ağ kesintisi, geçersiz kimlik bilgisi, yetkilendirme hatası) veya performans sorunları gibi kritik senaryolar genellikle mock edilmez. Bu durumda, CI’ımız bu eksiklikleri gözden kaçırır ve gerçek dünyada karşılaşılacak potansiyel hatalara karşı bizi koruyamaz.
  3. Yanlış Davranış Simülasyonu: Bir mock, sadece veri yapısını değil, aynı zamanda API’nın davranışını da taklit etmelidir. Örneğin, belirli bir girişe karşılık gelen belirli bir hata kodu veya bir durum değişikliğinin (state change) nasıl yönetildiği. Eğer mock bu davranışsal incelikleri doğru bir şekilde yansıtmazsa, uygulamanız gerçek API ile farklı, mock ile farklı davranır.
  4. Aşırı Basitleştirme: Geliştiriciler, testleri hızlıca geçirmek adına mock’ları aşırı basitleştirebilirler. Örneğin, gerçek API’nın karmaşık bir doğrulama mantığı varsa, mock bu mantığı tamamen atlayabilir ve her zaman başarılı bir yanıt dönebilir. Bu, yanıltıcı bir “her şey yolunda” hissi yaratır.

Peki, yalan söyleyen bir mock’un CI/CD boru hattı üzerindeki etkileri nelerdir?

  • Yanlış Pozitifler (False Positives): En tehlikeli etkilerden biridir. CI boru hattı yeşil yanar, tüm testler başarılı görünür, ancak bu başarı yanıltıcıdır. Uygulama, mock’a karşı doğru çalışırken, gerçek API’ya karşı çalışmayabilir. Bu, geliştiricilere yanlış bir güvenlik hissi verir.
  • Üretim Ortamında Hatalar: Yanlış pozitifler nedeniyle, hatalı kod parçacıkları üretim ortamına kadar ulaşabilir. Bu, gerçek kullanıcılar için kesintilere, veri kayıplarına veya kritik iş süreçlerinin aksamasına yol açabilir. Üretim ortamında hata ayıklamak hem maliyetli hem de streslidir.
  • Geliştirici Güveninin Kaybı: CI/CD boru hattına ve testlere olan güven azalır. Geliştiriciler, “Testler geçiyor ama yine de bozuk” düşüncesiyle karşı karşıya kalır. Bu durum, test yazma motivasyonunu düşürebilir ve süreçlere şüpheyle yaklaşmaya neden olabilir.
  • Hata Ayıklama Zorluğu ve Zaman Kaybı: Gerçek API ile entegrasyonda bir sorun çıktığında, sorunun kaynağını bulmak çok daha zor hale gelir. Sorun, kendi kodumuzda mı, mock’ta mı, yoksa gerçek API’da mı? Bu belirsizlik, hata ayıklama sürecini uzatır ve değerli geliştirme zamanını boşa harcar.
  • Gecikmiş Geri Bildirim: Hatalar, CI aşamasında yakalanmak yerine, genellikle entegrasyon testlerinin daha ileri aşamalarında (staging, pre-prod) veya en kötüsü üretimde ortaya çıkar. Bu, geri bildirim döngüsünü uzatır ve hatanın düzeltilme maliyetini artırır.

Özetle, mock’lar bize yalan söylediğinde, CI boru hattımız bir bekçi köpeği olmaktan çıkar, sadece kapının açık olduğunu düşündüren bir yanılsamaya dönüşür. Bu durum, yazılım geliştirme ekipleri için ciddi operasyonel ve itibar riskleri taşır. Bu nedenle, mock’ların doğruluğunu sağlamak, CI/CD stratejisinin ayrılmaz bir parçası olmalıdır.

Gerçek Dünya Senaryosu: Bir Ödeme Sağlayıcısı API’ı ile Yaşanan Kabus

Bu bölümde, mock’un bize yalan söylemesinin somut bir örneğini, bir e-ticaret platformunun ödeme entegrasyonu senaryosu üzerinden ele alalım. Senaryomuzda, “HızlıÖdeme” adında popüler bir ödeme geçidi sağlayıcısıyla entegre olmaya çalışan bir ekibimiz var. Uygulama, kullanıcılardan kredi kartı bilgilerini alıp HızlıÖdeme API’ına göndererek ödeme işlemini tamamlıyor.

Başlangıç Durumu ve Mock’lama Kararı:

Geliştirme ekibi, HızlıÖdeme API’ının test ortamının yavaş ve bazen kararsız olduğunu fark etti. Ayrıca, her test işlemi için küçük bir ücret alındığı bilgisi de vardı. Bu durumlar, CI/CD boru hattının her çalıştığında gerçek API’ya bağımlı kalmanın sürdürülemez olduğunu gösterdi. Ekip, birim testleri ve entegrasyon testlerinin ilk aşamaları için HızlıÖdeme API’ını mock’lamaya karar verdi. Bu sayede, testler hızlanacak ve maliyetler düşecekti.

İlk Mock Uygulaması:

Ekip, HızlıÖdeme API dokümantasyonundan faydalanarak basit bir mock servisi oluşturdu. Bu mock, belirli bir URL’ye yapılan POST isteğine karşılık, başarılı bir ödeme için aşağıdaki gibi bir JSON yanıtı dönüyordu:

{
  "status": "success",
  "transactionId": "TXN_123456789",
  "amount": 100.00,
  "currency": "TRY",
  "message": "Ödeme başarıyla tamamlandı."
}

Hata senaryoları için de benzer basit mock’lar tanımlandı (örneğin, geçersiz kart bilgisi için "status": "failed"). Bu mock’lar, uygulamanın ödeme servisi katmanını test etmek için kullanıldı. CI boru hattı yeşil yanıyor, her şey yolunda görünüyordu. Geliştirme süreci hızlandı, ekip mutlu bir şekilde yeni özellikler üzerinde çalışıyordu.

Mock’un Yalan Söylemesi Anı:

Birkaç ay sonra, HızlıÖdeme, API’ında önemli bir güncelleme yaptığını duyurdu. Güncelleme notlarında, güvenlik ve esneklik adına bazı alanların değiştirildiği ve yeni bir "paymentMethod" alanı eklendiği belirtildi. Ayrıca, "transactionId" alanı yerine artık "paymentReference" kullanılacağı ve başarılı ödemeler için HTTP durum kodunun 200 yerine 201 olacağı bilgisi yer alıyordu. Ekip, bu değişiklikleri gözden kaçırdı veya önceliklendiremedi. Mock servisi güncellenmedi.

Uygulama kodunda, transactionId alanını bekleyen ve HTTP 200 durum kodunu kontrol eden bir kısım vardı. Mock’lar hala eski yanıtları döndürdüğü için, CI boru hattı bu değişikliklerden habersizdi ve tüm testler başarılı bir şekilde geçmeye devam etti. Geliştiriciler, testlerin yeşil yanmasına güvenerek, yeni bir sürümü “staging” (sahneleme) ortamına dağıttılar.

Kabus Başlıyor: Staging Ortamında Gelen Şok

Staging ortamında gerçek HızlıÖdeme API’ı kullanılıyordu. Yeni sürüm dağıtıldıktan sonra, test ekibi ve bazı erken erişim kullanıcıları ödeme yapmaya çalıştıklarında, beklenmedik hatalarla karşılaştılar:

  • Ödemeler yapılıyordu, ancak uygulamanın kullanıcı arayüzünde (UI) ödeme başarılı olarak görünmüyor, “bir hata oluştu” mesajı gösteriliyordu.
  • Veritabanına kaydedilen işlem kimlikleri (transactionId) boş kalıyordu, çünkü uygulama gerçek API’dan dönen paymentReference alanını tanımıyordu.
  • Bazı durumlarda, ödeme başarılı olsa bile, uygulamanın akışı bir hata durumuna düşüyordu çünkü HTTP 200 yerine 201 döndüğünü beklemiyordu.

Ekip, durumu hızla araştırmaya başladı. İlk başta kendi kodlarında bir hata olduğunu düşündüler, ancak birim testleri ve entegrasyon testleri hala yeşil yanıyordu. Saatler süren hata ayıklama (debugging) ve ağ trafiği analizi (network traffic analysis) sonucunda, acı gerçek ortaya çıktı: Mock’lar onlara yalan söylemişti! Gerçek API’nın değiştiği, ancak mock’ların bu değişiklikleri yansıtmadığı anlaşıldı.

Alınan Dersler ve Çözüm:

Bu olay, ekibe mock’ların doğruluğunun ne kadar kritik olduğunu acı bir şekilde gösterdi. Çözüm, sadece mock’ları güncellemekten ibaret değildi; aynı zamanda gelecekte benzer durumların yaşanmasını engellemek için süreçleri de değiştirmekti:

  • API Dokümantasyon Takibi: Tedarikçi API’larının dokümantasyon değişikliklerini daha yakından takip etmek için bir süreç oluşturuldu.
  • Sözleşme Testleri (Contract Tests): Mock’lar ile gerçek API arasındaki sözleşmeyi (veri yapısı, durum kodları, alan isimleri vb.) doğrulayan otomatik testler yazıldı. Bu testler, CI boru hattına entegre edildi ve gerçek API’dan gelen örnek yanıtlarla mock yanıtlarını karşılaştırdı.
  • Daha Kapsamlı Entegrasyon Testleri: Staging ortamında gerçek API ile çalışan daha kapsamlı ve otomatik entegrasyon testleri yazıldı. Bu testler, kritik iş akışlarını uçtan uca (end-to-end) doğruladı.
  • Mock Servisi Güncelleme Sorumluluğu: Mock’ların güncelliğini korumak için belirli bir ekip üyesine veya rolüne sorumluluk atandı.

Bu senaryo, mock’ların sadece bir araç olduğunu ve yanlış yönetildiğinde faydadan çok zarar getirebileceğini açıkça göstermektedir. CI’ı kurtarmak isterken, aslında daha büyük bir soruna davetiye çıkarmıştık. Bu deneyim, mock’lama stratejilerinin sadece “nasıl” değil, aynı zamanda “nasıl güncel tutulacağı” ve “nasıl doğrulanacağı” sorularına da odaklanması gerektiğini vurguladı.

Mock’ların Doğruluğunu Nasıl Sağlarız? Stratejiler ve Araçlar

Bir mock’un bize yalan söylemesini engellemek ve CI/CD boru hattımızın güvenilirliğini artırmak için çeşitli stratejiler ve araçlar mevcuttur. Bu yaklaşımlar, mock’larımızın gerçek API ile olan sözleşmesini sürekli olarak doğrulamayı ve güncel tutmayı hedefler.

1. Sözleşme Testleri (Contract Testing)

Sözleşme testi, en güçlü doğrulama yöntemlerinden biridir. Bu yaklaşım, bir hizmetin (sağlayıcı) ve onu kullanan bir istemcinin (tüketici) birbirleriyle nasıl etkileşim kurduğunu tanımlayan bir “sözleşme” oluşturur. Bu sözleşme, API’nın beklenen isteklerini ve yanıtlarını, veri yapılarını, HTTP durum kodlarını ve hata mesajlarını içerir. Sözleşme testleri, bu sözleşmeye hem tüketicinin hem de sağlayıcının uyduğunu doğrular.

  • Tüketici Tarafı Sözleşme Testi (Consumer-Driven Contract Testing): Bu yaklaşımda, tüketici (yani bizim uygulamamız), dış API’dan beklediği sözleşmeyi tanımlar. Bu sözleşme daha sonra bir mock oluşturmak ve kendi testlerini çalıştırmak için kullanılır. Aynı sözleşme, gerçek API sağlayıcısının da kendi tarafında, API’ının bu sözleşmeye uyduğunu doğrulamak için kullanılır. Popüler araçlar arasında Pact ve Spring Cloud Contract bulunur.
  • Faydaları: Mock’larımızın gerçek API ile uyumlu olmasını sağlar, API değişiklikleri durumunda erken uyarı verir, bağımsız ekiplerin paralel çalışmasını kolaylaştırır.

Örnek bir Pact testi (pseudo-code):

// Tüketici tarafında (bizim uygulamamız)
// HızlıÖdeme API'ından beklenen bir sözleşme tanımlıyoruz
describe('HızlıÖdeme API', () => {
  it('başarılı bir ödeme yanıtı dönmelidir', async () => {
    const expectedResponse = {
      status: 'success',
      paymentReference: 'REF_987654321', // Yeni alan
      amount: 100.00,
      currency: 'TRY',
      message: 'Ödeme başarıyla tamamlandı.'
    };

    // Pact mock servisini başlat ve beklentiyi ayarla
    await provider.addInteraction({
      state: 'ödeme başarılı bir şekilde işlendiğinde',
      uponReceiving: 'ödeme isteği',
      withRequest: {
        method: 'POST',
        path: '/api/v1/payments',
        headers: { 'Content-Type': 'application/json' },
        body: {
          cardNumber: '...',
          expiryDate: '...',
          cvv: '...',
          amount: 100.00
        }
      },
      willRespondWith: {
        status: 201, // Yeni HTTP durumu
        headers: { 'Content-Type': 'application/json' },
        body: expectedResponse
      }
    });

    // Kendi ödeme servisimizle mock'a karşı bir istek yap
    const result = await myPaymentService.processPayment({ /* ... kart bilgileri ... */ });

    // Yanıtın beklenen yapıda olduğunu doğrula
    expect(result.status).toBe('success');
    expect(result.paymentReference).toBeDefined();

    // Pact etkileşimini doğrula (mock'a doğru çağrı yapıldığını kontrol eder)
    await provider.verify();
  });
});

2. OpenAPI/Swagger Tanımlarından Mock Üretimi

Birçok harici API, davranışlarını OpenAPI (eski adıyla Swagger) spesifikasyonları aracılığıyla tanımlar. Bu dosyalar, API’nın tüm uç noktalarını (endpoints), istek ve yanıt şemalarını, parametrelerini ve HTTP durum kodlarını detaylı bir şekilde açıklar. Bu spesifikasyonları kullanarak otomatik olarak mock servisleri veya istemci kodları (client code) üreten araçlar mevcuttur.

  • Araçlar: OpenAPI Generator, Stoplight Prism, Postman Mock Servers.
  • Faydaları: Mock’ların her zaman API spesifikasyonuyla uyumlu olmasını sağlar, manuel hata riskini azaltır, API güncellendiğinde mock’ların otomatik olarak yeniden üretilmesine olanak tanır.

3. Düzenli Senkronizasyon ve Doğrulama

Eğer sözleşme testleri veya otomatik üretim mümkün değilse, mock’larınızı düzenli olarak gerçek API ile senkronize etmek için manuel veya yarı otomatik süreçler oluşturmalısınız.

  • Manuel İnceleme: API sağlayıcısının dokümantasyonunu ve değişiklik günlüklerini (changelogs) periyodik olarak kontrol edin.
  • Gerçek API Yanıtlarını Kullanma: Gerçek API’dan alınan örnek yanıtları (örneğin, curl veya Postman ile) mock tanımlarınızı güncellemek için kullanın.
  • Test Ortamında Uçtan Uca Testler: CI boru hattının ileri aşamalarında (staging veya pre-prod), gerçek API’lar ile çalışan uçtan uca (end-to-end) entegrasyon testleri çalıştırmak, mock’ların gözden kaçırdığı sorunları yakalamak için hayati öneme sahiptir.

4. Dinamik Mock Servisleri

Basit JSON dosyaları yerine, daha gelişmiş mock sunucuları (örneğin WireMock, MockServer) kullanarak daha dinamik ve esnek mock’lar oluşturabilirsiniz. Bu araçlar şunları yapmanızı sağlar:

  • Koşullu Yanıtlar: Belirli istek parametrelerine, başlıklarına veya gövdelerine (body) göre farklı yanıtlar döndürme.
  • Durum Yönetimi (Stateful Mocks): API’nın durumunu taklit etme (örneğin, bir kaynak oluşturulduktan sonra onu “get” isteğiyle alabilme).
  • Gecikme Simülasyonu: Gerçek API’nın yanıt gecikmelerini taklit ederek performans testleri yapma.
  • Hata Enjeksiyonu: Belirli senaryolarda kasıtlı olarak hata yanıtları döndürme.

WireMock ile basit bir mock tanımı:

// Java (WireMock) örneği
WireMock.stubFor(WireMock.post(WireMock.urlEqualTo("/api/v1/payments"))
    .withRequestBody(WireMock.matchingJsonPath("$.amount", WireMock.equalTo("100.00")))
    .willReturn(WireMock.aResponse()
        .withStatus(201)
        .withHeader("Content-Type", "application/json")
        .withBody("{ \"status\": \"success\", \"paymentReference\": \"REF_987654321\" }")));

5. Versiyonlama ve Dokümantasyon

Mock’larınızı uygulamanızın diğer kodları gibi versiyonlayın ve iyi dokümante edin. Hangi mock’un hangi API versiyonunu taklit ettiğini açıkça belirtin. Bu, özellikle büyük ekiplerde ve birden fazla entegrasyonu olan projelerde karmaşıklığı yönetmek için önemlidir.

Bu stratejilerin kombinasyonu, mock’larınızın yalnızca testleri geçmesini değil, aynı zamanda gerçek API’nın davranışını doğru bir şekilde yansıtmasını sağlayarak CI/CD boru hattınızın gerçek değerini korumanıza yardımcı olacaktır. Unutmayın, mock’lar bir amaca hizmet eder, ancak bu amaca hizmet etmeyi bıraktıklarında, birer yük haline gelirler.

Gelişmiş Mock’lama Teknikleri ve En İyi Uygulamalar

Mock’lama, basit statik yanıtlar döndürmekten çok daha fazlasını sunar. Gelişmiş teknikler ve en iyi uygulamalar, mock’larınızı daha dinamik, gerçekçi ve sürdürülebilir hale getirerek test stratejinizi güçlendirir. Bu bölümde, daha deneyimli kullanıcılar için ipuçları ve püf noktaları ele alacağız.

1. Durum Yönetimi (Stateful Mocks)

Çoğu API, basit bir istek-yanıt döngüsünden daha karmaşık bir yaşam döngüsüne sahiptir. Örneğin, bir kaynak önce oluşturulur, sonra güncellenir ve ardından silinir. Stateless (durumsuz) mock’lar bu tür senaryoları taklit edemez. Stateful mock’lar ise, gelen isteklere göre iç durumlarını değiştirebilir ve sonraki isteklere farklı yanıtlar verebilir.

  • Nasıl Uygulanır: WireMock gibi araçlar, durumu yönetmek için “senaryolar” (scenarios) veya “durum makinesi” (state machine) kavramlarını destekler. Bir isteğe yanıt verdikten sonra, mock’un durumunu “bekleyen”den “işlendi”ye değiştirebilir ve bu duruma göre farklı yanıtlar tanımlayabilirsiniz.
  • Örnek Senaryo: Bir sipariş API’ı. Sipariş oluşturulduğunda 201 yanıtı döner ve durum “pending” olur. Ardından bir “sipariş durumu sorgula” isteği yapıldığında, siparişin durumuna göre “pending”, “shipped” veya “delivered” gibi farklı yanıtlar dönebilir.

2. Dinamik Yanıtlar ve Şablonlama

Bazen mock yanıtlarının, gelen isteğin içeriğine göre dinamik olarak değişmesi gerekir. Örneğin, bir kullanıcı ID’si ile yapılan bir istek için, yanıtta o ID’nin tekrar dönmesi beklenebilir. Şablonlama (templating) motorları bu ihtiyacı karşılar.

  • Araçlar: Handlebars (WireMock’ta), Apache Velocity, Jinja2.
  • Nasıl Uygulanır: Mock tanımınızda, yanıta dinamik değerler eklemek için şablon değişkenleri kullanırsınız. Örneğin, istek gövdesindeki bir alanı alıp yanıt gövdesine yerleştirebilirsiniz.
// WireMock (Handlebars ile dinamik yanıt)
WireMock.stubFor(WireMock.post(WireMock.urlEqualTo("/api/v1/users"))
    .willReturn(WireMock.aResponse()
        .withStatus(201)
        .withHeader("Content-Type", "application/json")
        .withBody("{ \"id\": \"{{jsonPath request.body '$.id'}}\", \"name\": \"{{jsonPath request.body '$.name'}}\", \"status\": \"created\" }")));

3. Hata Enjeksiyonu ve Gecikme Simülasyonu

Uygulamalarımızın sadece “mutlu yol” senaryolarında değil, aynı zamanda API’nın hata döndürdüğü veya yavaş yanıt verdiği durumlarda da düzgün çalışıp çalışmadığını test etmek kritiktir. Mock’lar, bu tür senaryoları simüle etmek için idealdir.

  • Hata Enjeksiyonu: Belirli bir yüzdeyle veya belirli bir isteğe karşılık 500 Internal Server Error, 401 Unauthorized gibi hata kodları döndürün. Bu, uygulamanızın hata yönetimi (error handling) ve geri dönüş (fallback) mekanizmalarını test etmenize olanak tanır.
  • Gecikme Simülasyonu: Mock yanıtlarına kasıtlı gecikmeler (latency) ekleyin. Bu, uygulamanızın kullanıcı arayüzünde yükleme göstergelerinin (loading indicators) doğru çalışıp çalışmadığını, zaman aşımlarının (timeouts) beklendiği gibi işleyip işlemediğini veya asenkron işlemlerin doğru yönetilip yönetilmediğini test etmenizi sağlar.

4. CI/CD Boru Hattına Entegrasyon

Mock’lama çözümlerinizin CI/CD boru hattınızla sorunsuz bir şekilde entegre olması, onların etkinliğini artırır.

  • Otomatik Başlatma/Durdurma: Testler başlamadan önce mock servislerini otomatik olarak başlatın ve testler bittikten sonra durdurun. Docker konteynerleri bu konuda oldukça kullanışlıdır.
  • Yapılandırma Yönetimi: Mock’ların yapılandırmasını (örneğin, farklı ortamlar için farklı mock senaryoları) CI/CD değişkenleri veya yapılandırma dosyaları aracılığıyla yönetin.
  • Raporlama: Mock’lar aracılığıyla yapılan çağrıların ve doğrulama sonuçlarının CI raporlarına dahil edildiğinden emin olun.

5. Mock’ların Sahipliği ve Bakımı

Mock’ların “yalan söylemesini” engellemek için, onların da kod gibi sahiplenilmesi ve bakımının yapılması gerekir.

  • Sorumluluk Ataması: Hangi ekibin veya kişinin belirli bir mock’un güncelliğinden sorumlu olduğunu belirleyin.
  • Kod Olarak Mock’lar (Mocks as Code): Mock tanımlarını versiyon kontrol sisteminde (Git gibi) saklayın. Bu, değişikliklerin izlenmesini, gözden geçirilmesini ve geri alınmasını kolaylaştırır.
  • Dokümantasyon: Her mock’un neyi taklit ettiğini, hangi senaryoları kapsadığını ve neden kullanıldığını açıklayan iyi bir dokümantasyon sağlayın.

6. Gerçek API Yanıtlarını Kaydetme ve Oynatma (Record/Replay)

Bazı araçlar (örneğin WireMock, VCR), gerçek API çağrılarını kaydedip daha sonra bu kayıtları mock olarak oynatma yeteneği sunar. Bu, mock’ları oluşturmanın ve güncellemenin hızlı bir yoludur, ancak kaydedilen yanıtların güncelliğini yine de kontrol etmek gerekir.

Bu gelişmiş teknikler ve en iyi uygulamalar, mock’lama stratejinizi olgunlaştırarak, testlerinizin sadece hızlı değil, aynı zamanda güvenilir olmasını sağlar. Mock’lar, doğru kullanıldığında, yazılım geliştirme sürecinizin hızını ve kalitesini önemli ölçüde artırabilir.

Mock’larınızı Canlı Tutmak: Sürekli Bakım ve Otomasyon

API mock’lama, geliştirme ve test süreçlerimize hız ve esneklik katarken, bu mock’ların doğruluğunu ve güncelliğini sürekli olarak sağlamak kritik bir zorluktur. Bir mock’un “yalan söylemesi” durumunu yaşamamak için, onları yaşayan bir varlık gibi görüp düzenli bakımını yapmak ve mümkün olduğunca otomatikleştirmek gerekir. İşte bu konuda izlenebilecek adımlar ve en iyi uygulamalar:

1. Otomatik Doğrulama Mekanizmaları

Mock’larınızı manuel olarak kontrol etmek zaman alıcı ve hataya açık bir süreçtir. Bu nedenle, otomatik doğrulama mekanizmaları kurmak esastır.

  • Sözleşme Testlerinin CI’a Entegrasyonu: Daha önce bahsedildiği gibi, Pact gibi araçlarla yazılan sözleşme testlerini CI boru hattınızın ayrılmaz bir parçası haline getirin. Bu testler, hem mock’larınızın hem de gerçek API’nın sözleşmeye uyup uymadığını otomatik olarak kontrol eder. Gerçek API’da bir değişiklik olduğunda, bu testler hemen başarısız olur ve size erken uyarı verir.
  • Periyodik Gerçek API Karşılaştırmaları: Belirli aralıklarla (örneğin, her gece veya haftalık), mock’larınızın döndürdüğü yanıtları, gerçek API’dan alınan güncel yanıtlarla otomatik olarak karşılaştıran bir iş (job) çalıştırın. Bu, yanıt yapılarındaki veya veri tiplerindeki beklenmedik farkları tespit etmenize yardımcı olur. Bu karşılaştırmaları yapmak için özel olarak yazılmış betikler (scripts) veya test otomasyon araçları kullanılabilir.
  • API Şeması Doğrulaması: Eğer API’nın OpenAPI/Swagger şeması mevcutsa, mock yanıtlarınızın bu şemaya uygunluğunu otomatik olarak doğrulayan testler yazın. Bu, veri tiplerinin, zorunlu alanların ve alan isimlerinin doğru olmasını sağlar.

2. Düzenli Gözden Geçirme ve Güncelleme Döngüleri

Otomasyon ne kadar güçlü olursa olsun, insan faktörü ve düzenli gözden geçirme döngüleri vazgeçilmezdir.

  • API Sağlayıcı Değişiklik Günlüklerinin Takibi: Tedarikçi API’larının dokümantasyonunu, değişiklik günlüklerini (changelogs) ve duyurularını düzenli olarak takip edin. Bu değişiklikler, mock’larınızın güncellenmesi gerektiğinin ilk işaretleridir. Bir “API değişiklik takipçisi” rolü atamak faydalı olabilir.
  • Periyodik Mock Gözden Geçirme Toplantıları: Geliştirme ekibi olarak, belirli aralıklarla (örneğin, aylık) mock’larınızı gözden geçirin. Hangi mock’ların hala geçerli olduğunu, hangilerinin güncellenmesi gerektiğini veya hangilerinin artık gereksiz olduğunu tartışın.
  • Kapsam Analizi: Mevcut mock’larınızın, uygulamanızın kullandığı tüm kritik API uç noktalarını ve senaryolarını (başarılı, hata, kenar durumları) kapsayıp kapsamadığını değerlendirin. Yeni geliştirilen özellikler veya eklenen bağımlılıklar için yeni mock’lar oluşturulması gerekebilir.

3. Geri Bildirim Mekanizmaları ve Uyarılar

Bir mock’un güncelliğini yitirdiğini veya gerçek API’dan farklılaştığını mümkün olan en kısa sürede öğrenmelisiniz.

  • CI/CD Boru Hattı Bildirimleri: Otomatik doğrulama testleri başarısız olduğunda, ekibe (Slack, e-posta vb. aracılığıyla) anında bildirim gönderin. Bu, sorunun hızlıca fark edilip çözülmesini sağlar.
  • Performans ve Hata İzleme (Monitoring): Üretim ortamında gerçek API entegrasyonlarınızın performansını ve hata oranlarını izleyin. Eğer mock’larınız yeterince gerçekçi değilse, üretimdeki hatalar veya performans düşüşleri, mock’larınızın iyileştirilmesi gerektiğini işaret edebilir.

4. “Kod Olarak Mock” Yaklaşımı

Mock tanımlarını ve yapılandırmalarını diğer tüm kod varlıkları gibi versiyon kontrol sisteminde (Git) saklayın. Bu yaklaşım, mock’ların yaşam döngüsünü yönetmeyi kolaylaştırır:

  • Versiyonlama: Mock’lar da kod gibi versiyonlanır. Bu, belirli bir uygulama sürümünün hangi mock versiyonunu kullandığını takip etmenizi sağlar.
  • Değişiklik Takibi: Mock’larda yapılan değişiklikler Git geçmişinde izlenebilir. Kimin, ne zaman, hangi değişikliği yaptığını görmek mümkündür.
  • Kod İncelemesi (Code Review): Mock değişiklikleri de diğer kod değişiklikleri gibi gözden geçirme süreçlerinden geçebilir. Bu, hatalı veya eksik mock tanımlarının tespit edilmesine yardımcı olur.
  • Dağıtım Otomasyonu: Mock servislerinizin dağıtımını (örneğin, Docker konteynerleri olarak) otomatikleştirebilirsiniz.

5. Ekip İçi İşbirliği ve Eğitim

Mock’ların etkinliği, tüm ekibin bu konudaki bilincine ve işbirliğine bağlıdır.

  • Bilgi Paylaşımı: API değişiklikleri veya mock güncellemeleri hakkında ekip içinde düzenli bilgi paylaşımı yapın.
  • Eğitim: Yeni ekip üyelerine mock’lama stratejileri, araçları ve en iyi uygulamalar hakkında eğitim verin.
  • Sahiplik: Mock’ların sadece “test ekibinin” değil, tüm geliştirme ekibinin ortak sorumluluğunda olduğunu vurgulayın.

Mock’ları canlı tutmak, sürekli bir çaba gerektirir. Ancak bu çaba, CI/CD boru hattınızın güvenilirliğini, geliştirme hızınızı ve nihayetinde yazılımınızın kalitesini artırarak fazlasıyla karşılığını verir. Unutmayın, iyi yönetilmeyen bir mock, testlerinizi geçirse bile sizi üretimde başarısızlığa sürükleyebilir.

Sonuç ve Sıkça Sorulan Sorular

API mock’lama, modern yazılım geliştirme süreçlerinde harici bağımlılıkları yönetmek, testleri hızlandırmak ve maliyetleri düşürmek için vazgeçilmez bir tekniktir. Ancak, bu makalede detaylıca incelediğimiz gibi, mock’lar bize “yalan söylediğinde”, yani gerçek API’nın davranışını doğru bir şekilde yansıtmadığında, bu avantajlar hızla kabusa dönüşebilir. CI boru hattının yeşil yanmasıyla gelen yanlış pozitifler, üretim ortamında beklenmedik hatalara, geliştirici güveninin kaybına ve uzun süren hata ayıklama süreçlerine yol açabilir.

Bu deneyimden çıkarılacak en önemli ders, mock’ların sadece bir araç olduğu ve diğer tüm kod varlıkları gibi düzenli bakım, doğrulama ve otomasyon gerektirdiğidir. Sözleşme testleri, OpenAPI/Swagger spesifikasyonlarından mock üretimi, dinamik mock servisleri ve sürekli entegrasyon boru hattına derinlemesine entegrasyon gibi stratejiler, mock’larınızın doğruluğunu sağlamanın anahtarıdır. Mock’larınızı “canlı” tutarak, CI/CD boru hattınızın gerçek bir kalite güvencesi mekanizması olmasını sağlayabilir, geliştirme hızınızı koruyabilir ve son kullanıcılarınıza daha güvenilir ürünler sunabilirsiniz.

Sıkça Sorulan Sorular (SSS)

1. API mock’lama neden bu kadar önemli?

API mock’lama, harici bağımlılıkları (üçüncü taraf API’ları) izole ederek test süreçlerini hızlandırır, maliyetleri düşürür ve CI/CD boru hattının kararlılığını artırır. Gerçek API’ların yavaşlığı, maliyeti veya erişilemezliği gibi sorunları ortadan kaldırarak geliştiricilerin kendi kodlarına odaklanmasını sağlar.

2. Bir mock’un “yalan söylemesi” ne anlama gelir?

Bir mock’un “yalan söylemesi”, simüle ettiği gerçek API’nın davranışını, veri yapısını veya hata senaryolarını doğru bir şekilde yansıtmaması demektir. Bu durum, gerçek API’nın değişmesi ancak mock’un güncellenmemesi, eksik senaryoların mock edilmesi veya mock’un aşırı basitleştirilmesi gibi nedenlerle ortaya çıkabilir.

3. Yalan söyleyen bir mock’un CI/CD boru hattına etkisi nedir?

Yalan söyleyen bir mock, CI boru hattında yanlış pozitiflere (tüm testler geçse bile kodun hatalı olması) yol açar. Bu durum, hatalı kodun üretim ortamına ulaşmasına, geliştirici güveninin sarsılmasına ve hata ayıklama süreçlerinin uzamasına neden olur.

4. Mock’ların doğruluğunu nasıl sağlayabiliriz?

Mock’ların doğruluğunu sağlamak için sözleşme testleri (Pact gibi), OpenAPI/Swagger spesifikasyonlarından otomatik mock üretimi, dinamik mock servisleri (WireMock gibi), düzenli senkronizasyon ve otomasyon araçları kullanılabilir. Ayrıca, mock’ların da kod gibi versiyonlanması ve düzenli olarak gözden geçirilmesi önemlidir.

5. Sözleşme testleri (Contract Testing) mock’larla nasıl ilişkilidir?

Sözleşme testleri, mock’ların doğruluğunu sağlamanın en etkili yollarından biridir. Bu testler, uygulamanızın (tüketici) harici bir API’dan (sağlayıcı) beklediği sözleşmeyi tanımlar. Bu sözleşme hem mock’larınızı oluşturmak hem de gerçek API’nın bu sözleşmeye uyduğunu doğrulamak için kullanılır. Böylece, mock’unuzun gerçek API ile her zaman uyumlu kalması sağlanır.

#API #Mocklama #CI/CD #YazılımGeliştirme #TestOtomasyonu #SözleşmeTesti #WebServisleri #DevOps

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Gönder

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.
Mobil sürümden çık